Deploy Rankora API: buy box competitors, offers persistence, scraper fixes

README.md

@@ -1,13 +1,13 @@
----
-title: Rankora API
-emoji: 📊
-colorFrom: red
-colorTo: purple
-sdk: docker
-app_port: 7860
-pinned: false
----
-
-# Rankora Backend API
-
-FastAPI backend for Rankora Amazon intelligence platform.
+---
+title: Rankora API
+emoji: 📊
+colorFrom: red
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Rankora Backend API
+
+FastAPI backend for Rankora Amazon intelligence platform.

app/database.py

@@ -1,74 +1,78 @@
-from sqlalchemy import create_engine, text
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-import os
-
-from app.config import settings
-
-DATABASE_URL = settings.database_url or os.getenv("DATABASE_URL", "sqlite:///./amazon_intel.db")
-
-if DATABASE_URL.startswith("sqlite"):
-    engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
-else:
-    engine = create_engine(DATABASE_URL, pool_pre_ping=True, pool_recycle=300)
-
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-Base = declarative_base()
-
-
-def migrate_schema():
-    """Add columns when schema evolves (SQLite + PostgreSQL)."""
-    user_alters = [
-        "ALTER TABLE users ADD COLUMN token_version INTEGER DEFAULT 0",
-    ]
-    sqlite_product_alters = [
-        "ALTER TABLE products ADD COLUMN seller_count INTEGER",
-        "ALTER TABLE products ADD COLUMN buy_box_winner VARCHAR(255)",
-        "ALTER TABLE products ADD COLUMN buy_box_price NUMERIC(10,2)",
-        "ALTER TABLE products ADD COLUMN buy_box_is_fba BOOLEAN DEFAULT 1",
-        "ALTER TABLE products ADD COLUMN is_amazon_sold BOOLEAN DEFAULT 0",
-        "ALTER TABLE products ADD COLUMN last_data_source VARCHAR(20) DEFAULT 'cached'",
-        "ALTER TABLE products ADD COLUMN upc VARCHAR(20)",
-        "ALTER TABLE products ADD COLUMN has_buy_box BOOLEAN DEFAULT 1",
-        "ALTER TABLE products ADD COLUMN package_weight_lbs NUMERIC(8,3)",
-    ]
-    pg_product_alters = [
-        "ALTER TABLE products ADD COLUMN IF NOT EXISTS upc VARCHAR(20)",
-        "ALTER TABLE products ADD COLUMN IF NOT EXISTS has_buy_box BOOLEAN DEFAULT TRUE",
-        "ALTER TABLE products ADD COLUMN IF NOT EXISTS package_weight_lbs NUMERIC(8,3)",
-    ]
-    is_pg = DATABASE_URL.startswith("postgresql")
-    with engine.connect() as conn:
-        for sql in user_alters:
-            try:
-                if is_pg:
-                    conn.execute(text(
-                        "ALTER TABLE users ADD COLUMN IF NOT EXISTS token_version INTEGER DEFAULT 0"
-                    ))
-                else:
-                    conn.execute(text(sql))
-                conn.commit()
-            except Exception:
-                pass
-        if DATABASE_URL.startswith("sqlite"):
-            for sql in sqlite_product_alters:
-                try:
-                    conn.execute(text(sql))
-                    conn.commit()
-                except Exception:
-                    pass
-        if is_pg:
-            for sql in pg_product_alters:
-                try:
-                    conn.execute(text(sql))
-                    conn.commit()
-                except Exception:
-                    pass
-
-
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
+from sqlalchemy import create_engine, text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+
+from app.config import settings
+
+DATABASE_URL = settings.database_url or os.getenv("DATABASE_URL", "sqlite:///./amazon_intel.db")
+
+if DATABASE_URL.startswith("sqlite"):
+    engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+else:
+    engine = create_engine(DATABASE_URL, pool_pre_ping=True, pool_recycle=300)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+def migrate_schema():
+    """Add columns when schema evolves (SQLite + PostgreSQL)."""
+    user_alters = [
+        "ALTER TABLE users ADD COLUMN token_version INTEGER DEFAULT 0",
+    ]
+    sqlite_product_alters = [
+        "ALTER TABLE products ADD COLUMN seller_count INTEGER",
+        "ALTER TABLE products ADD COLUMN buy_box_winner VARCHAR(255)",
+        "ALTER TABLE products ADD COLUMN buy_box_price NUMERIC(10,2)",
+        "ALTER TABLE products ADD COLUMN buy_box_is_fba BOOLEAN DEFAULT 1",
+        "ALTER TABLE products ADD COLUMN is_amazon_sold BOOLEAN DEFAULT 0",
+        "ALTER TABLE products ADD COLUMN last_data_source VARCHAR(20) DEFAULT 'cached'",
+        "ALTER TABLE products ADD COLUMN upc VARCHAR(20)",
+        "ALTER TABLE products ADD COLUMN has_buy_box BOOLEAN DEFAULT 1",
+        "ALTER TABLE products ADD COLUMN package_weight_lbs NUMERIC(8,3)",
+        "ALTER TABLE products ADD COLUMN other_sellers_json TEXT",
+        "ALTER TABLE products ADD COLUMN offers_source VARCHAR(30)",
+    ]
+    pg_product_alters = [
+        "ALTER TABLE products ADD COLUMN IF NOT EXISTS upc VARCHAR(20)",
+        "ALTER TABLE products ADD COLUMN IF NOT EXISTS has_buy_box BOOLEAN DEFAULT TRUE",
+        "ALTER TABLE products ADD COLUMN IF NOT EXISTS package_weight_lbs NUMERIC(8,3)",
+        "ALTER TABLE products ADD COLUMN IF NOT EXISTS other_sellers_json TEXT",
+        "ALTER TABLE products ADD COLUMN IF NOT EXISTS offers_source VARCHAR(30)",
+    ]
+    is_pg = DATABASE_URL.startswith("postgresql")
+    with engine.connect() as conn:
+        for sql in user_alters:
+            try:
+                if is_pg:
+                    conn.execute(text(
+                        "ALTER TABLE users ADD COLUMN IF NOT EXISTS token_version INTEGER DEFAULT 0"
+                    ))
+                else:
+                    conn.execute(text(sql))
+                conn.commit()
+            except Exception:
+                pass
+        if DATABASE_URL.startswith("sqlite"):
+            for sql in sqlite_product_alters:
+                try:
+                    conn.execute(text(sql))
+                    conn.commit()
+                except Exception:
+                    pass
+        if is_pg:
+            for sql in pg_product_alters:
+                try:
+                    conn.execute(text(sql))
+                    conn.commit()
+                except Exception:
+                    pass
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/dependencies.py

@@ -1,51 +1,51 @@
-from fastapi import Depends, HTTPException
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from jose import jwt, JWTError
-from sqlalchemy.orm import Session
-
-from app.database import get_db
-from app.models.user import User
-from app.config import settings
-from app.security.token_revocation import is_jti_revoked
-
-security = HTTPBearer()
-
-
-def get_current_user(
-    credentials: HTTPAuthorizationCredentials = Depends(security),
-    db: Session = Depends(get_db),
-) -> User:
-    token = credentials.credentials
-    try:
-        payload = jwt.decode(token, settings.secret_key, algorithms=[settings.algorithm])
-        user_id: str = payload.get("sub")
-        jti: str | None = payload.get("jti")
-        token_version: int = int(payload.get("tv") or 0)
-        if not user_id:
-            raise HTTPException(status_code=401, detail="Invalid token")
-        if is_jti_revoked(jti):
-            raise HTTPException(status_code=401, detail="Token revoked")
-    except JWTError:
-        raise HTTPException(status_code=401, detail="Invalid token")
-
-    user = db.query(User).filter(User.id == user_id).first()
-    if not user:
-        raise HTTPException(status_code=401, detail="User not found")
-    if not user.is_active:
-        raise HTTPException(status_code=403, detail="Account deactivated")
-    if token_version != (user.token_version or 0):
-        raise HTTPException(status_code=401, detail="Token expired — please log in again")
-    return user
-
-
-def enforce_search_limit(user: User, db: Session) -> None:
-    """Optional per-plan monthly cap. Off by default until plans/billing ship."""
-    if not settings.enforce_search_limits:
-        return
-    if user.monthly_searches >= user.search_limit:
-        raise HTTPException(
-            status_code=429,
-            detail=f"Monthly search limit reached ({user.search_limit}). Upgrade your plan or wait until next month.",
-        )
-    user.monthly_searches += 1
-    db.commit()
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import jwt, JWTError
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.models.user import User
+from app.config import settings
+from app.security.token_revocation import is_jti_revoked
+
+security = HTTPBearer()
+
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    db: Session = Depends(get_db),
+) -> User:
+    token = credentials.credentials
+    try:
+        payload = jwt.decode(token, settings.secret_key, algorithms=[settings.algorithm])
+        user_id: str = payload.get("sub")
+        jti: str | None = payload.get("jti")
+        token_version: int = int(payload.get("tv") or 0)
+        if not user_id:
+            raise HTTPException(status_code=401, detail="Invalid token")
+        if is_jti_revoked(jti):
+            raise HTTPException(status_code=401, detail="Token revoked")
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid token")
+
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=401, detail="User not found")
+    if not user.is_active:
+        raise HTTPException(status_code=403, detail="Account deactivated")
+    if token_version != (user.token_version or 0):
+        raise HTTPException(status_code=401, detail="Token expired — please log in again")
+    return user
+
+
+def enforce_search_limit(user: User, db: Session) -> None:
+    """Optional per-plan monthly cap. Off by default until plans/billing ship."""
+    if not settings.enforce_search_limits:
+        return
+    if user.monthly_searches >= user.search_limit:
+        raise HTTPException(
+            status_code=429,
+            detail=f"Monthly search limit reached ({user.search_limit}). Upgrade your plan or wait until next month.",
+        )
+    user.monthly_searches += 1
+    db.commit()

app/models/__init__.py

@@ -1,3 +1,3 @@
-from app.models.user import User
-from app.models.product import Product, PriceHistory, TrackedProduct, BuyBoxSnapshot
+from app.models.user import User
+from app.models.product import Product, PriceHistory, TrackedProduct, BuyBoxSnapshot
 from app.models.tracking import PriceAlert

app/models/product.py

@@ -1,65 +1,67 @@
-from sqlalchemy import Column, String, Boolean, Integer, DateTime, Numeric, Text
-from sqlalchemy.sql import func
-from app.database import Base
-import uuid
-
-def gen_uuid():
-    return str(uuid.uuid4())
-
-class Product(Base):
-    __tablename__ = "products"
-    __table_args__ = {"extend_existing": True}
-    id           = Column(String(36), primary_key=True, default=gen_uuid)
-    asin         = Column(String(10), unique=True, nullable=False)
-    title        = Column(Text, nullable=True)
-    brand        = Column(String(255), nullable=True)
-    upc          = Column(String(20), nullable=True)
-    category     = Column(String(255), nullable=True)
-    image_url    = Column(Text, nullable=True)
-    amazon_url   = Column(Text, nullable=True)
-    is_prime     = Column(Boolean, default=True)
-    seller_count = Column(Integer, nullable=True)
-    buy_box_winner = Column(String(255), nullable=True)
-    buy_box_price  = Column(Numeric(10, 2), nullable=True)
-    buy_box_is_fba = Column(Boolean, default=True)
-    has_buy_box    = Column(Boolean, default=True)
-    is_amazon_sold = Column(Boolean, default=False)
-    package_weight_lbs = Column(Numeric(8, 3), nullable=True)
-    last_data_source = Column(String(20), default="cached")
-    last_synced_at = Column(DateTime(timezone=True), nullable=True)
-    created_at   = Column(DateTime(timezone=True), server_default=func.now())
-
-class PriceHistory(Base):
-    __tablename__ = "price_history"
-    __table_args__ = {"extend_existing": True}
-    id           = Column(String(36), primary_key=True, default=gen_uuid)
-    product_id   = Column(String(36), nullable=False)
-    price        = Column(Numeric(10, 2), nullable=True)
-    bsr          = Column(Integer, nullable=True)
-    rating       = Column(Numeric(3, 2), nullable=True)
-    review_count = Column(Integer, nullable=True)
-    in_stock     = Column(Boolean, default=True)
-    recorded_at  = Column(DateTime(timezone=True), server_default=func.now())
-
-class TrackedProduct(Base):
-    __tablename__ = "tracked_products"
-    __table_args__ = {"extend_existing": True}
-    id         = Column(String(36), primary_key=True, default=gen_uuid)
-    user_id    = Column(String(36), nullable=False)
-    product_id = Column(String(36), nullable=False)
-    tracked_at = Column(DateTime(timezone=True), server_default=func.now())
-
-
-class BuyBoxSnapshot(Base):
-    """Point-in-time Buy Box winner captured on each product refresh."""
-    __tablename__ = "buy_box_snapshots"
-    __table_args__ = {"extend_existing": True}
-    id            = Column(String(36), primary_key=True, default=gen_uuid)
-    product_id    = Column(String(36), nullable=False, index=True)
-    winner        = Column(String(255), nullable=True)
-    price         = Column(Numeric(10, 2), nullable=True)
-    is_fba        = Column(Boolean, nullable=True)
-    is_amazon     = Column(Boolean, default=False)
-    seller_count  = Column(Integer, nullable=True)
-    has_buy_box   = Column(Boolean, default=True)
+from sqlalchemy import Column, String, Boolean, Integer, DateTime, Numeric, Text
+from sqlalchemy.sql import func
+from app.database import Base
+import uuid
+
+def gen_uuid():
+    return str(uuid.uuid4())
+
+class Product(Base):
+    __tablename__ = "products"
+    __table_args__ = {"extend_existing": True}
+    id           = Column(String(36), primary_key=True, default=gen_uuid)
+    asin         = Column(String(10), unique=True, nullable=False)
+    title        = Column(Text, nullable=True)
+    brand        = Column(String(255), nullable=True)
+    upc          = Column(String(20), nullable=True)
+    category     = Column(String(255), nullable=True)
+    image_url    = Column(Text, nullable=True)
+    amazon_url   = Column(Text, nullable=True)
+    is_prime     = Column(Boolean, default=True)
+    seller_count = Column(Integer, nullable=True)
+    buy_box_winner = Column(String(255), nullable=True)
+    buy_box_price  = Column(Numeric(10, 2), nullable=True)
+    buy_box_is_fba = Column(Boolean, default=True)
+    has_buy_box    = Column(Boolean, default=True)
+    is_amazon_sold = Column(Boolean, default=False)
+    package_weight_lbs = Column(Numeric(8, 3), nullable=True)
+    other_sellers_json = Column(Text, nullable=True)
+    offers_source = Column(String(30), nullable=True)
+    last_data_source = Column(String(20), default="cached")
+    last_synced_at = Column(DateTime(timezone=True), nullable=True)
+    created_at   = Column(DateTime(timezone=True), server_default=func.now())
+
+class PriceHistory(Base):
+    __tablename__ = "price_history"
+    __table_args__ = {"extend_existing": True}
+    id           = Column(String(36), primary_key=True, default=gen_uuid)
+    product_id   = Column(String(36), nullable=False)
+    price        = Column(Numeric(10, 2), nullable=True)
+    bsr          = Column(Integer, nullable=True)
+    rating       = Column(Numeric(3, 2), nullable=True)
+    review_count = Column(Integer, nullable=True)
+    in_stock     = Column(Boolean, default=True)
+    recorded_at  = Column(DateTime(timezone=True), server_default=func.now())
+
+class TrackedProduct(Base):
+    __tablename__ = "tracked_products"
+    __table_args__ = {"extend_existing": True}
+    id         = Column(String(36), primary_key=True, default=gen_uuid)
+    user_id    = Column(String(36), nullable=False)
+    product_id = Column(String(36), nullable=False)
+    tracked_at = Column(DateTime(timezone=True), server_default=func.now())
+
+
+class BuyBoxSnapshot(Base):
+    """Point-in-time Buy Box winner captured on each product refresh."""
+    __tablename__ = "buy_box_snapshots"
+    __table_args__ = {"extend_existing": True}
+    id            = Column(String(36), primary_key=True, default=gen_uuid)
+    product_id    = Column(String(36), nullable=False, index=True)
+    winner        = Column(String(255), nullable=True)
+    price         = Column(Numeric(10, 2), nullable=True)
+    is_fba        = Column(Boolean, nullable=True)
+    is_amazon     = Column(Boolean, default=False)
+    seller_count  = Column(Integer, nullable=True)
+    has_buy_box   = Column(Boolean, default=True)
     recorded_at   = Column(DateTime(timezone=True), server_default=func.now(), index=True)

app/models/tracking.py

@@ -1,18 +1,18 @@
-from sqlalchemy import Column, String, Float, Integer, DateTime, Boolean
-from app.database import Base
-from datetime import datetime, timezone
-
-
-class PriceAlert(Base):
-    """Price alerts — separate from PriceHistory in product.py"""
-    __tablename__ = "price_alerts"
-    __table_args__ = {"extend_existing": True}
-    id           = Column(Integer, primary_key=True, autoincrement=True)
-    user_id      = Column(String, index=True)
-    asin         = Column(String, index=True)
-    alert_type   = Column(String)
-    threshold    = Column(Float)
-    is_active    = Column(Boolean, default=True)
-    triggered    = Column(Boolean, default=False)
-    triggered_at = Column(DateTime, nullable=True)
+from sqlalchemy import Column, String, Float, Integer, DateTime, Boolean
+from app.database import Base
+from datetime import datetime, timezone
+
+
+class PriceAlert(Base):
+    """Price alerts — separate from PriceHistory in product.py"""
+    __tablename__ = "price_alerts"
+    __table_args__ = {"extend_existing": True}
+    id           = Column(Integer, primary_key=True, autoincrement=True)
+    user_id      = Column(String, index=True)
+    asin         = Column(String, index=True)
+    alert_type   = Column(String)
+    threshold    = Column(Float)
+    is_active    = Column(Boolean, default=True)
+    triggered    = Column(Boolean, default=False)
+    triggered_at = Column(DateTime, nullable=True)
     created_at   = Column(DateTime, default=lambda: datetime.now(timezone.utc))

app/models/user.py

@@ -1,22 +1,22 @@
-from sqlalchemy import Column, String, Boolean, Integer, DateTime
-from sqlalchemy.sql import func
-from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy import text
-from app.database import Base
-import uuid
-
-class User(Base):
-    __tablename__ = "users"
-
-    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    email = Column(String(255), unique=True, nullable=False)
-    password_hash = Column(String(255), nullable=False)
-    full_name = Column(String(255), nullable=True)
-    plan = Column(String(20), default="free")
-    monthly_searches = Column(Integer, default=0)
-    search_limit = Column(Integer, default=50)
-    is_active = Column(Boolean, default=True)
-    is_verified = Column(Boolean, default=False)
-    token_version = Column(Integer, default=0)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
+from sqlalchemy import Column, String, Boolean, Integer, DateTime
+from sqlalchemy.sql import func
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy import text
+from app.database import Base
+import uuid
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    email = Column(String(255), unique=True, nullable=False)
+    password_hash = Column(String(255), nullable=False)
+    full_name = Column(String(255), nullable=True)
+    plan = Column(String(20), default="free")
+    monthly_searches = Column(Integer, default=0)
+    search_limit = Column(Integer, default=50)
+    is_active = Column(Boolean, default=True)
+    is_verified = Column(Boolean, default=False)
+    token_version = Column(Integer, default=0)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
     updated_at = Column(DateTime(timezone=True), onupdate=func.now())

app/routers/advanced_router.py

@@ -1,152 +1,152 @@
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
-from pydantic import BaseModel, Field
-from typing import Optional, Literal
-
-from app.database import get_db
-from app.dependencies import get_current_user, enforce_search_limit
-from app.models.user import User
-from app.models.product import Product, PriceHistory, TrackedProduct
-from app.services.analytics.tracking_service import (
-    record_price, get_price_history, create_alert, get_alerts, check_alerts
-)
-from app.services.analytics.advanced_services import (
-    estimate_sales_v2, analyze_reviews, analyze_niche,
-    generate_keywords, analyze_buy_box
-)
-from app.security.input_guard import scan_user_text
-from app.utils.validators import normalize_asin
-
-router = APIRouter(prefix="/api/v2", tags=["Advanced Features"])
-
-ALLOWED_ALERT_TYPES = {"price_drop", "price_increase", "bsr_change", "review_spike"}
-
-
-class AlertCreate(BaseModel):
-    asin: str = Field(max_length=10)
-    alert_type: str = Field(max_length=32)
-    threshold: float = Field(ge=0, le=1_000_000)
-
-
-class TrackRequest(BaseModel):
-    asin: str = Field(max_length=10)
-    title: Optional[str] = Field(default=None, max_length=500)
-    price: Optional[float] = None
-    bsr: Optional[int] = None
-    reviews: Optional[int] = None
-    rating: Optional[float] = None
-
-
-class NicheRequest(BaseModel):
-    keyword: str = Field(max_length=120)
-    avg_bsr: float = Field(default=50000, ge=1, le=50_000_000)
-    avg_reviews: float = Field(default=200, ge=0, le=10_000_000)
-    avg_price: float = Field(default=25.0, ge=0, le=100_000)
-    product_count: int = Field(default=100, ge=1, le=100_000)
-
-
-class SalesRequest(BaseModel):
-    bsr: int = Field(ge=1, le=50_000_000)
-    category: str = Field(default="default", max_length=120)
-    price: float = Field(default=25.0, ge=0, le=100_000)
-
-
-class ReviewRequest(BaseModel):
-    rating: float = Field(ge=0, le=5)
-    review_count: int = Field(ge=0, le=50_000_000)
-    title: str = Field(default="", max_length=500)
-
-
-class BuyBoxRequest(BaseModel):
-    price: float = Field(ge=0, le=100_000)
-    rating: float = Field(default=4.5, ge=0, le=5)
-    review_count: int = Field(default=100, ge=0, le=50_000_000)
-    is_fba: bool = True
-    is_prime: bool = True
-
-
-class KeywordRequest(BaseModel):
-    seed_keyword: str = Field(max_length=120)
-    category: str = Field(default="", max_length=120)
-
-
-@router.get("/track/{asin}/history")
-def price_history(asin: str, days: int = 30, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    asin = normalize_asin(asin)
-    days = min(max(days, 1), 365)
-    history = get_price_history(db, asin, days)
-    return {"asin": asin, "days": days, "history": history, "count": len(history)}
-
-
-@router.get("/track/list")
-def tracked_list(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    tracked = db.query(TrackedProduct).filter(TrackedProduct.user_id == str(current_user.id)).all()
-    result = []
-    for t in tracked:
-        product = db.query(Product).filter(Product.id == t.product_id).first()
-        if product:
-            latest = db.query(PriceHistory).filter(PriceHistory.product_id == product.id).order_by(PriceHistory.recorded_at.desc()).first()
-            result.append({
-                "asin": product.asin,
-                "title": product.title,
-                "tracked_since": t.tracked_at.isoformat() if t.tracked_at else None,
-                "price": float(latest.price) if latest and latest.price else None,
-                "bsr": latest.bsr if latest else None,
-            })
-    return {"products": result}
-
-
-@router.post("/alerts")
-def create_alert_endpoint(req: AlertCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    asin = normalize_asin(req.asin)
-    alert_type = req.alert_type.strip().lower()
-    if alert_type not in ALLOWED_ALERT_TYPES:
-        raise HTTPException(status_code=400, detail="Invalid alert type")
-    alert = create_alert(db, str(current_user.id), asin, alert_type, req.threshold)
-    return {"created": True, "alert_id": alert.id, "type": alert_type, "threshold": req.threshold}
-
-
-@router.get("/alerts")
-def list_alerts(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    alerts = get_alerts(db, str(current_user.id))
-    return {"alerts": [{"id": a.id, "asin": a.asin, "type": a.alert_type, "threshold": a.threshold, "triggered": a.triggered} for a in alerts]}
-
-
-@router.post("/sales-estimate")
-def sales_estimate(req: SalesRequest, current_user: User = Depends(get_current_user)):
-    category = scan_user_text(req.category, "category") if req.category != "default" else "default"
-    return estimate_sales_v2(req.bsr, category, req.price)
-
-
-@router.post("/review-analysis")
-def review_analysis(req: ReviewRequest, current_user: User = Depends(get_current_user)):
-    title = scan_user_text(req.title, "title") if req.title else ""
-    return analyze_reviews(req.rating, req.review_count, title)
-
-
-@router.post("/buy-box")
-def buy_box(req: BuyBoxRequest, current_user: User = Depends(get_current_user)):
-    return analyze_buy_box(req.price, req.rating, req.review_count, req.is_fba, req.is_prime)
-
-
-@router.post("/niche")
-def niche_finder(req: NicheRequest, current_user: User = Depends(get_current_user)):
-    keyword = scan_user_text(req.keyword, "keyword")
-    return analyze_niche(keyword, req.avg_bsr, req.avg_reviews, req.avg_price, req.product_count)
-
-
-@router.post("/keywords")
-def keyword_research(req: KeywordRequest, current_user: User = Depends(get_current_user)):
-    seed = scan_user_text(req.seed_keyword, "seed_keyword")
-    category = scan_user_text(req.category, "category") if req.category else ""
-    return generate_keywords(seed, category)
-
-
-@router.get("/full-analysis/{asin}")
-def full_analysis(asin: str, price: float = 25.0, bsr: int = 50000, reviews: int = 200, rating: float = 4.0, category: str = "default", db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    asin = normalize_asin(asin)
-    sales     = estimate_sales_v2(bsr, category, price)
-    review_a  = analyze_reviews(rating, reviews)
-    buy_box_a = analyze_buy_box(price, rating, reviews)
-    history   = get_price_history(db, asin, 30)
-    return {"asin": asin, "sales_estimate": sales, "review_analysis": review_a, "buy_box": buy_box_a, "price_history": history}
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from pydantic import BaseModel, Field
+from typing import Optional, Literal
+
+from app.database import get_db
+from app.dependencies import get_current_user, enforce_search_limit
+from app.models.user import User
+from app.models.product import Product, PriceHistory, TrackedProduct
+from app.services.analytics.tracking_service import (
+    record_price, get_price_history, create_alert, get_alerts, check_alerts
+)
+from app.services.analytics.advanced_services import (
+    estimate_sales_v2, analyze_reviews, analyze_niche,
+    generate_keywords, analyze_buy_box
+)
+from app.security.input_guard import scan_user_text
+from app.utils.validators import normalize_asin
+
+router = APIRouter(prefix="/api/v2", tags=["Advanced Features"])
+
+ALLOWED_ALERT_TYPES = {"price_drop", "price_increase", "bsr_change", "review_spike"}
+
+
+class AlertCreate(BaseModel):
+    asin: str = Field(max_length=10)
+    alert_type: str = Field(max_length=32)
+    threshold: float = Field(ge=0, le=1_000_000)
+
+
+class TrackRequest(BaseModel):
+    asin: str = Field(max_length=10)
+    title: Optional[str] = Field(default=None, max_length=500)
+    price: Optional[float] = None
+    bsr: Optional[int] = None
+    reviews: Optional[int] = None
+    rating: Optional[float] = None
+
+
+class NicheRequest(BaseModel):
+    keyword: str = Field(max_length=120)
+    avg_bsr: float = Field(default=50000, ge=1, le=50_000_000)
+    avg_reviews: float = Field(default=200, ge=0, le=10_000_000)
+    avg_price: float = Field(default=25.0, ge=0, le=100_000)
+    product_count: int = Field(default=100, ge=1, le=100_000)
+
+
+class SalesRequest(BaseModel):
+    bsr: int = Field(ge=1, le=50_000_000)
+    category: str = Field(default="default", max_length=120)
+    price: float = Field(default=25.0, ge=0, le=100_000)
+
+
+class ReviewRequest(BaseModel):
+    rating: float = Field(ge=0, le=5)
+    review_count: int = Field(ge=0, le=50_000_000)
+    title: str = Field(default="", max_length=500)
+
+
+class BuyBoxRequest(BaseModel):
+    price: float = Field(ge=0, le=100_000)
+    rating: float = Field(default=4.5, ge=0, le=5)
+    review_count: int = Field(default=100, ge=0, le=50_000_000)
+    is_fba: bool = True
+    is_prime: bool = True
+
+
+class KeywordRequest(BaseModel):
+    seed_keyword: str = Field(max_length=120)
+    category: str = Field(default="", max_length=120)
+
+
+@router.get("/track/{asin}/history")
+def price_history(asin: str, days: int = 30, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    asin = normalize_asin(asin)
+    days = min(max(days, 1), 365)
+    history = get_price_history(db, asin, days)
+    return {"asin": asin, "days": days, "history": history, "count": len(history)}
+
+
+@router.get("/track/list")
+def tracked_list(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    tracked = db.query(TrackedProduct).filter(TrackedProduct.user_id == str(current_user.id)).all()
+    result = []
+    for t in tracked:
+        product = db.query(Product).filter(Product.id == t.product_id).first()
+        if product:
+            latest = db.query(PriceHistory).filter(PriceHistory.product_id == product.id).order_by(PriceHistory.recorded_at.desc()).first()
+            result.append({
+                "asin": product.asin,
+                "title": product.title,
+                "tracked_since": t.tracked_at.isoformat() if t.tracked_at else None,
+                "price": float(latest.price) if latest and latest.price else None,
+                "bsr": latest.bsr if latest else None,
+            })
+    return {"products": result}
+
+
+@router.post("/alerts")
+def create_alert_endpoint(req: AlertCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    asin = normalize_asin(req.asin)
+    alert_type = req.alert_type.strip().lower()
+    if alert_type not in ALLOWED_ALERT_TYPES:
+        raise HTTPException(status_code=400, detail="Invalid alert type")
+    alert = create_alert(db, str(current_user.id), asin, alert_type, req.threshold)
+    return {"created": True, "alert_id": alert.id, "type": alert_type, "threshold": req.threshold}
+
+
+@router.get("/alerts")
+def list_alerts(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    alerts = get_alerts(db, str(current_user.id))
+    return {"alerts": [{"id": a.id, "asin": a.asin, "type": a.alert_type, "threshold": a.threshold, "triggered": a.triggered} for a in alerts]}
+
+
+@router.post("/sales-estimate")
+def sales_estimate(req: SalesRequest, current_user: User = Depends(get_current_user)):
+    category = scan_user_text(req.category, "category") if req.category != "default" else "default"
+    return estimate_sales_v2(req.bsr, category, req.price)
+
+
+@router.post("/review-analysis")
+def review_analysis(req: ReviewRequest, current_user: User = Depends(get_current_user)):
+    title = scan_user_text(req.title, "title") if req.title else ""
+    return analyze_reviews(req.rating, req.review_count, title)
+
+
+@router.post("/buy-box")
+def buy_box(req: BuyBoxRequest, current_user: User = Depends(get_current_user)):
+    return analyze_buy_box(req.price, req.rating, req.review_count, req.is_fba, req.is_prime)
+
+
+@router.post("/niche")
+def niche_finder(req: NicheRequest, current_user: User = Depends(get_current_user)):
+    keyword = scan_user_text(req.keyword, "keyword")
+    return analyze_niche(keyword, req.avg_bsr, req.avg_reviews, req.avg_price, req.product_count)
+
+
+@router.post("/keywords")
+def keyword_research(req: KeywordRequest, current_user: User = Depends(get_current_user)):
+    seed = scan_user_text(req.seed_keyword, "seed_keyword")
+    category = scan_user_text(req.category, "category") if req.category else ""
+    return generate_keywords(seed, category)
+
+
+@router.get("/full-analysis/{asin}")
+def full_analysis(asin: str, price: float = 25.0, bsr: int = 50000, reviews: int = 200, rating: float = 4.0, category: str = "default", db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    asin = normalize_asin(asin)
+    sales     = estimate_sales_v2(bsr, category, price)
+    review_a  = analyze_reviews(rating, reviews)
+    buy_box_a = analyze_buy_box(price, rating, reviews)
+    history   = get_price_history(db, asin, 30)
+    return {"asin": asin, "sales_estimate": sales, "review_analysis": review_a, "buy_box": buy_box_a, "price_history": history}

app/routers/analysis.py

@@ -1,104 +1,104 @@
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
-from app.database import get_db
-from app.dependencies import get_current_user
-from app.models.user import User
-from app.models.product import Product, PriceHistory
-from app.services.analytics.ai_analyzer import generate_ai_analysis
-from app.services.amazon.sales_estimator import estimate_monthly_sales, calculate_opportunity_score
-import csv
-import io
-from fastapi.responses import StreamingResponse
-
-router = APIRouter(prefix="/api/analysis", tags=["Analysis"])
-
-@router.get("/{asin}/ai")
-def get_ai_analysis(
-    asin: str,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    product = db.query(Product).filter(Product.asin == asin.upper()).first()
-    if not product:
-        raise HTTPException(status_code=404, detail="Product not found. Fetch it first.")
-    
-    latest = (
-        db.query(PriceHistory)
-        .filter(PriceHistory.product_id == product.id)
-        .order_by(PriceHistory.recorded_at.desc())
-        .first()
-    )
-    
-    sales_data = estimate_monthly_sales(latest.bsr if latest else 0, product.category or "")
-    opportunity_score = None
-    if latest and sales_data["monthly_units"]:
-        opportunity_score = calculate_opportunity_score(
-            bsr=latest.bsr or 0,
-            review_count=latest.review_count or 0,
-            monthly_sales=sales_data["monthly_units"],
-            seller_count=1
-        )
-    
-    product_data = {
-        "asin": product.asin,
-        "title": product.title,
-        "category": product.category,
-        "current_price": float(latest.price) if latest and latest.price else None,
-        "current_bsr": latest.bsr if latest else None,
-        "current_rating": float(latest.rating) if latest and latest.rating else None,
-        "current_review_count": latest.review_count if latest else None,
-        "sales_estimate_monthly": sales_data["monthly_units"],
-        "revenue_estimate_monthly": round(sales_data["monthly_units"] * float(latest.price), 2) if sales_data["monthly_units"] and latest and latest.price else None,
-        "opportunity_score": opportunity_score,
-    }
-    
-    analysis = generate_ai_analysis(product_data)
-    return {
-        "asin": asin,
-        "product_title": product.title,
-        **analysis,
-    }
-
-
-@router.get("/export/csv")
-def export_tracked_csv(
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    from app.models.product import TrackedProduct
-    
-    tracked_list = db.query(TrackedProduct).filter(
-        TrackedProduct.user_id == current_user.id
-    ).all()
-    
-    output = io.StringIO()
-    writer = csv.writer(output)
-    writer.writerow(["ASIN", "Title", "Brand", "Category", "Price", "BSR", "Rating", "Reviews", "Tracked At"])
-    
-    for t in tracked_list:
-        product = db.query(Product).filter(Product.id == t.product_id).first()
-        if product:
-            latest = (
-                db.query(PriceHistory)
-                .filter(PriceHistory.product_id == product.id)
-                .order_by(PriceHistory.recorded_at.desc())
-                .first()
-            )
-            writer.writerow([
-                product.asin,
-                product.title,
-                product.brand or "",
-                product.category or "",
-                float(latest.price) if latest and latest.price else "",
-                latest.bsr if latest else "",
-                float(latest.rating) if latest and latest.rating else "",
-                latest.review_count if latest else "",
-                t.tracked_at.strftime("%Y-%m-%d %H:%M") if t.tracked_at else "",
-            ])
-    
-    output.seek(0)
-    return StreamingResponse(
-        iter([output.getvalue()]),
-        media_type="text/csv",
-        headers={"Content-Disposition": "attachment; filename=tracked_products.csv"}
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.dependencies import get_current_user
+from app.models.user import User
+from app.models.product import Product, PriceHistory
+from app.services.analytics.ai_analyzer import generate_ai_analysis
+from app.services.amazon.sales_estimator import estimate_monthly_sales, calculate_opportunity_score
+import csv
+import io
+from fastapi.responses import StreamingResponse
+
+router = APIRouter(prefix="/api/analysis", tags=["Analysis"])
+
+@router.get("/{asin}/ai")
+def get_ai_analysis(
+    asin: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    product = db.query(Product).filter(Product.asin == asin.upper()).first()
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found. Fetch it first.")
+    
+    latest = (
+        db.query(PriceHistory)
+        .filter(PriceHistory.product_id == product.id)
+        .order_by(PriceHistory.recorded_at.desc())
+        .first()
+    )
+    
+    sales_data = estimate_monthly_sales(latest.bsr if latest else 0, product.category or "")
+    opportunity_score = None
+    if latest and sales_data["monthly_units"]:
+        opportunity_score = calculate_opportunity_score(
+            bsr=latest.bsr or 0,
+            review_count=latest.review_count or 0,
+            monthly_sales=sales_data["monthly_units"],
+            seller_count=1
+        )
+    
+    product_data = {
+        "asin": product.asin,
+        "title": product.title,
+        "category": product.category,
+        "current_price": float(latest.price) if latest and latest.price else None,
+        "current_bsr": latest.bsr if latest else None,
+        "current_rating": float(latest.rating) if latest and latest.rating else None,
+        "current_review_count": latest.review_count if latest else None,
+        "sales_estimate_monthly": sales_data["monthly_units"],
+        "revenue_estimate_monthly": round(sales_data["monthly_units"] * float(latest.price), 2) if sales_data["monthly_units"] and latest and latest.price else None,
+        "opportunity_score": opportunity_score,
+    }
+    
+    analysis = generate_ai_analysis(product_data)
+    return {
+        "asin": asin,
+        "product_title": product.title,
+        **analysis,
+    }
+
+
+@router.get("/export/csv")
+def export_tracked_csv(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    from app.models.product import TrackedProduct
+    
+    tracked_list = db.query(TrackedProduct).filter(
+        TrackedProduct.user_id == current_user.id
+    ).all()
+    
+    output = io.StringIO()
+    writer = csv.writer(output)
+    writer.writerow(["ASIN", "Title", "Brand", "Category", "Price", "BSR", "Rating", "Reviews", "Tracked At"])
+    
+    for t in tracked_list:
+        product = db.query(Product).filter(Product.id == t.product_id).first()
+        if product:
+            latest = (
+                db.query(PriceHistory)
+                .filter(PriceHistory.product_id == product.id)
+                .order_by(PriceHistory.recorded_at.desc())
+                .first()
+            )
+            writer.writerow([
+                product.asin,
+                product.title,
+                product.brand or "",
+                product.category or "",
+                float(latest.price) if latest and latest.price else "",
+                latest.bsr if latest else "",
+                float(latest.rating) if latest and latest.rating else "",
+                latest.review_count if latest else "",
+                t.tracked_at.strftime("%Y-%m-%d %H:%M") if t.tracked_at else "",
+            ])
+    
+    output.seek(0)
+    return StreamingResponse(
+        iter([output.getvalue()]),
+        media_type="text/csv",
+        headers={"Content-Disposition": "attachment; filename=tracked_products.csv"}
     )

app/routers/auth.py

@@ -1,97 +1,97 @@
-from fastapi import APIRouter, Depends, HTTPException, Request, status
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from sqlalchemy.orm import Session
-from datetime import datetime, timedelta
-from jose import jwt, JWTError
-import bcrypt
-
-from app.database import get_db
-from app.models.user import User
-from app.schemas.user import UserRegister, UserLogin, Token, UserResponse, LogoutResponse
-from app.config import settings
-from app.dependencies import get_current_user, security
-from app.security.input_guard import assert_password_safe, scan_user_text
-from app.security.rate_limit import enforce_auth_rate_limit
-from app.security.token_revocation import new_jti, revoke_jti
-
-router = APIRouter(prefix="/api/auth", tags=["Authentication"])
-
-
-def hash_password(password: str) -> str:
-    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
-
-
-def verify_password(plain: str, hashed: str) -> bool:
-    return bcrypt.checkpw(plain.encode("utf-8"), hashed.encode("utf-8"))
-
-
-def create_token(user: User) -> str:
-    expire = datetime.utcnow() + timedelta(minutes=settings.access_token_expire_minutes)
-    to_encode = {
-        "sub": str(user.id),
-        "email": user.email,
-        "jti": new_jti(),
-        "tv": user.token_version or 0,
-        "iat": datetime.utcnow(),
-        "exp": expire,
-    }
-    return jwt.encode(to_encode, settings.secret_key, algorithm=settings.algorithm)
-
-
-@router.post("/register", response_model=Token)
-def register(user_data: UserRegister, request: Request, db: Session = Depends(get_db)):
-    enforce_auth_rate_limit(request, "register")
-    assert_password_safe(user_data.password)
-    email = str(user_data.email).lower().strip()[:254]
-    full_name = scan_user_text(user_data.full_name, "full_name") if user_data.full_name else None
-    if db.query(User).filter(User.email == email).first():
-        raise HTTPException(status_code=400, detail="Email already registered")
-    user = User(
-        email=email,
-        password_hash=hash_password(user_data.password),
-        full_name=full_name,
-        token_version=0,
-    )
-    db.add(user)
-    db.commit()
-    db.refresh(user)
-    token = create_token(user)
-    return Token(access_token=token, token_type="bearer", user=UserResponse.model_validate(user))
-
-
-@router.post("/login", response_model=Token)
-def login(credentials: UserLogin, request: Request, db: Session = Depends(get_db)):
-    enforce_auth_rate_limit(request, "login")
-    assert_password_safe(credentials.password)
-    email = str(credentials.email).lower().strip()[:254]
-    user = db.query(User).filter(User.email == email).first()
-    if not user or not verify_password(credentials.password, user.password_hash):
-        raise HTTPException(status_code=401, detail="Invalid email or password")
-    if not user.is_active:
-        raise HTTPException(status_code=403, detail="Account deactivated")
-    token = create_token(user)
-    return Token(access_token=token, token_type="bearer", user=UserResponse.model_validate(user))
-
-
-@router.post("/logout", response_model=LogoutResponse)
-def logout(
-    credentials: HTTPAuthorizationCredentials = Depends(security),
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db),
-):
-    """Invalidate token (replay protection) — bumps token_version and revokes jti."""
-    try:
-        payload = jwt.decode(credentials.credentials, settings.secret_key, algorithms=[settings.algorithm])
-        jti = payload.get("jti")
-        exp = payload.get("exp")
-        revoke_jti(jti, float(exp) if exp else None)
-    except JWTError:
-        pass
-    current_user.token_version = (current_user.token_version or 0) + 1
-    db.commit()
-    return LogoutResponse(message="Logged out")
-
-
-@router.get("/me", response_model=UserResponse)
-def get_me(current_user: User = Depends(get_current_user)):
-    return current_user
+from fastapi import APIRouter, Depends, HTTPException, Request, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+from datetime import datetime, timedelta
+from jose import jwt, JWTError
+import bcrypt
+
+from app.database import get_db
+from app.models.user import User
+from app.schemas.user import UserRegister, UserLogin, Token, UserResponse, LogoutResponse
+from app.config import settings
+from app.dependencies import get_current_user, security
+from app.security.input_guard import assert_password_safe, scan_user_text
+from app.security.rate_limit import enforce_auth_rate_limit
+from app.security.token_revocation import new_jti, revoke_jti
+
+router = APIRouter(prefix="/api/auth", tags=["Authentication"])
+
+
+def hash_password(password: str) -> str:
+    return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    return bcrypt.checkpw(plain.encode("utf-8"), hashed.encode("utf-8"))
+
+
+def create_token(user: User) -> str:
+    expire = datetime.utcnow() + timedelta(minutes=settings.access_token_expire_minutes)
+    to_encode = {
+        "sub": str(user.id),
+        "email": user.email,
+        "jti": new_jti(),
+        "tv": user.token_version or 0,
+        "iat": datetime.utcnow(),
+        "exp": expire,
+    }
+    return jwt.encode(to_encode, settings.secret_key, algorithm=settings.algorithm)
+
+
+@router.post("/register", response_model=Token)
+def register(user_data: UserRegister, request: Request, db: Session = Depends(get_db)):
+    enforce_auth_rate_limit(request, "register")
+    assert_password_safe(user_data.password)
+    email = str(user_data.email).lower().strip()[:254]
+    full_name = scan_user_text(user_data.full_name, "full_name") if user_data.full_name else None
+    if db.query(User).filter(User.email == email).first():
+        raise HTTPException(status_code=400, detail="Email already registered")
+    user = User(
+        email=email,
+        password_hash=hash_password(user_data.password),
+        full_name=full_name,
+        token_version=0,
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    token = create_token(user)
+    return Token(access_token=token, token_type="bearer", user=UserResponse.model_validate(user))
+
+
+@router.post("/login", response_model=Token)
+def login(credentials: UserLogin, request: Request, db: Session = Depends(get_db)):
+    enforce_auth_rate_limit(request, "login")
+    assert_password_safe(credentials.password)
+    email = str(credentials.email).lower().strip()[:254]
+    user = db.query(User).filter(User.email == email).first()
+    if not user or not verify_password(credentials.password, user.password_hash):
+        raise HTTPException(status_code=401, detail="Invalid email or password")
+    if not user.is_active:
+        raise HTTPException(status_code=403, detail="Account deactivated")
+    token = create_token(user)
+    return Token(access_token=token, token_type="bearer", user=UserResponse.model_validate(user))
+
+
+@router.post("/logout", response_model=LogoutResponse)
+def logout(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    """Invalidate token (replay protection) — bumps token_version and revokes jti."""
+    try:
+        payload = jwt.decode(credentials.credentials, settings.secret_key, algorithms=[settings.algorithm])
+        jti = payload.get("jti")
+        exp = payload.get("exp")
+        revoke_jti(jti, float(exp) if exp else None)
+    except JWTError:
+        pass
+    current_user.token_version = (current_user.token_version or 0) + 1
+    db.commit()
+    return LogoutResponse(message="Logged out")
+
+
+@router.get("/me", response_model=UserResponse)
+def get_me(current_user: User = Depends(get_current_user)):
+    return current_user

app/routers/competitors.py

@@ -1,45 +1,45 @@
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
-
-from app.database import get_db
-from app.dependencies import get_current_user
-from app.models.user import User
-from app.models.product import Product, PriceHistory
-from app.services.amazon.competitor_service import get_competitors_for_product
-from app.utils.validators import normalize_asin
-
-router = APIRouter(prefix="/api/competitors", tags=["Competitors"])
-
-
-@router.get("/{asin}")
-def get_competitors(
-    asin: str,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    asin = normalize_asin(asin)
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        raise HTTPException(status_code=404, detail="Product not found. Fetch it first.")
-
-    latest = (
-        db.query(PriceHistory)
-        .filter(PriceHistory.product_id == product.id)
-        .order_by(PriceHistory.recorded_at.desc())
-        .first()
-    )
-
-    competitors, data_source = get_competitors_for_product(
-        asin, product.category or "default", product.title or ""
-    )
-
-    return {
-        "asin": asin,
-        "product_title": product.title,
-        "product_price": float(latest.price) if latest and latest.price else None,
-        "product_bsr": latest.bsr if latest else None,
-        "product_rating": float(latest.rating) if latest and latest.rating else None,
-        "competitors": competitors,
-        "total_competitors": len(competitors),
-        "data_source": data_source,
-    }
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.dependencies import get_current_user
+from app.models.user import User
+from app.models.product import Product, PriceHistory
+from app.services.amazon.competitor_service import get_competitors_for_product
+from app.utils.validators import normalize_asin
+
+router = APIRouter(prefix="/api/competitors", tags=["Competitors"])
+
+
+@router.get("/{asin}")
+def get_competitors(
+    asin: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    asin = normalize_asin(asin)
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found. Fetch it first.")
+
+    latest = (
+        db.query(PriceHistory)
+        .filter(PriceHistory.product_id == product.id)
+        .order_by(PriceHistory.recorded_at.desc())
+        .first()
+    )
+
+    competitors, data_source = get_competitors_for_product(
+        asin, product.category or "default", product.title or ""
+    )
+
+    return {
+        "asin": asin,
+        "product_title": product.title,
+        "product_price": float(latest.price) if latest and latest.price else None,
+        "product_bsr": latest.bsr if latest else None,
+        "product_rating": float(latest.rating) if latest and latest.rating else None,
+        "competitors": competitors,
+        "total_competitors": len(competitors),
+        "data_source": data_source,
+    }

app/routers/keywords.py

@@ -1,31 +1,31 @@
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
-from app.database import get_db
-from app.dependencies import get_current_user
-from app.models.user import User
-from app.models.product import Product
-from app.services.amazon.keyword_service import get_keywords_for_product
-
-from app.utils.validators import normalize_asin
-
-router = APIRouter(prefix="/api/keywords", tags=["Keywords"])
-
-@router.get("/{asin}")
-def get_keywords(
-    asin: str,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    asin = normalize_asin(asin)
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        raise HTTPException(status_code=404, detail="Product not found. Fetch it first via /api/products/{asin}")
-    
-    keywords = get_keywords_for_product(product.title, asin)
-    
-    return {
-        "asin": asin,
-        "product_title": product.title,
-        "keywords": keywords,
-        "total": len(keywords)
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.dependencies import get_current_user
+from app.models.user import User
+from app.models.product import Product
+from app.services.amazon.keyword_service import get_keywords_for_product
+
+from app.utils.validators import normalize_asin
+
+router = APIRouter(prefix="/api/keywords", tags=["Keywords"])
+
+@router.get("/{asin}")
+def get_keywords(
+    asin: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    asin = normalize_asin(asin)
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found. Fetch it first via /api/products/{asin}")
+    
+    keywords = get_keywords_for_product(product.title, asin)
+    
+    return {
+        "asin": asin,
+        "product_title": product.title,
+        "keywords": keywords,
+        "total": len(keywords)
     }

app/routers/ml_router.py

@@ -1,277 +1,277 @@
-# app/routers/ml_router.py
-# ─────────────────────────────────────────────────────────────────────────────
-# ML Analysis Router — 5 endpoints
-#   GET  /api/ml/fake-reviews/{asin}      — fake review detection
-#   GET  /api/ml/price-prediction/{asin}  — price forecast
-#   GET  /api/ml/demand-forecast/{asin}   — demand forecast
-#   GET  /api/ml/niche-score/{asin}       — niche opportunity score
-#   GET  /api/ml/full-analysis/{asin}     — all 4 combined
-# ─────────────────────────────────────────────────────────────────────────────
-
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.orm import Session
-
-from app.database import get_db
-from app.dependencies import get_current_user
-from app.models.user import User
-from app.models.product import Product, PriceHistory, TrackedProduct
-from app.services.ml.fake_review_detector import detect_fake_reviews
-from app.services.ml.price_predictor      import predict_price
-from app.services.ml.demand_forecaster    import forecast_demand
-from app.services.ml.niche_scorer         import calculate_niche_score
-
-router = APIRouter(prefix="/api/ml", tags=["ML Features"])
-
-
-# ── Helper: load product + latest data from DB ─────────────────────────────
-def _load_product_data(asin: str, db: Session) -> dict:
-    """
-    Load product and its price history from the database.
-    Returns a unified dict of all available fields.
-    Raises 404 if product not found.
-    """
-    product = db.query(Product).filter(Product.asin == asin.upper()).first()
-    if not product:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Product {asin} not found. Search for it first using GET /api/products/{asin}",
-        )
-
-    # Load price history (last 30 records)
-    history_rows = (
-        db.query(PriceHistory)
-        .filter(PriceHistory.product_id == str(product.id))
-        .order_by(PriceHistory.recorded_at.desc())
-        .limit(30)
-        .all()
-    )
-
-    # Latest snapshot
-    latest = history_rows[0] if history_rows else None
-
-    # Serialised history for ML models
-    history_list = [
-        {
-            "price":        float(h.price) if h.price else None,
-            "bsr":          h.bsr,
-            "rating":       float(h.rating) if h.rating else None,
-            "review_count": h.review_count,
-            "recorded_at":  h.recorded_at.isoformat(),
-        }
-        for h in reversed(history_rows)
-    ]
-
-    # Estimate monthly sales from BSR (reuse your existing estimator)
-    from app.services.amazon.sales_estimator import estimate_monthly_sales
-    bsr          = latest.bsr if latest else None
-    category     = product.category or ""
-    sales_data   = estimate_monthly_sales(bsr or 0, category)
-    monthly_sales = sales_data.get("monthly_units", 0)
-
-    # Price — handle PKR→USD
-    raw_price = float(latest.price) if latest and latest.price else 0.0
-    PKR_THRESHOLD = 500
-    PKR_TO_USD    = 278.0
-    price = round(raw_price / PKR_TO_USD, 2) if raw_price > PKR_THRESHOLD else raw_price
-
-    return {
-        "asin":           product.asin,
-        "title":          product.title,
-        "category":       category,
-        "is_fba":         product.is_prime,   # prime = FBA proxy
-        "is_prime":       product.is_prime,
-        "price":          price,
-        "bsr":            bsr,
-        "rating":         float(latest.rating) if latest and latest.rating else 0.0,
-        "review_count":   latest.review_count if latest else 0,
-        "in_stock":       latest.in_stock if latest else True,
-        "monthly_sales":  monthly_sales,
-        "seller_count":   product.seller_count or 1,
-        "history":        history_list,
-    }
-
-
-# ── 1. Fake Review Detection ─────────────────────────────────────────────────
-@router.get(
-    "/fake-reviews/{asin}",
-    summary="Detect fake review patterns for a product",
-)
-def fake_review_analysis(
-    asin: str,
-    db: Session = Depends(get_db),
-    _: User = Depends(get_current_user),
-):
-    data   = _load_product_data(asin, db)
-    result = detect_fake_reviews(
-        review_count  = data["review_count"],
-        rating        = data["rating"],
-        bsr           = data["bsr"],
-        monthly_sales = data["monthly_sales"],
-        seller_count  = data["seller_count"],
-        is_fba        = data["is_fba"],
-    )
-    return {
-        "asin":     asin,
-        "title":    data["title"],
-        "analysis": result,
-    }
-
-
-# ── 2. Price Prediction ───────────────────────────────────────────────────────
-@router.get(
-    "/price-prediction/{asin}",
-    summary="Predict price movement for next 30/60/90 days",
-)
-def price_prediction(
-    asin: str,
-    db:   Session = Depends(get_db),
-    _:    User    = Depends(get_current_user),
-):
-    data   = _load_product_data(asin, db)
-    result = predict_price(
-        current_price = data["price"],
-        bsr           = data["bsr"],
-        rating        = data["rating"],
-        review_count  = data["review_count"],
-        seller_count  = data["seller_count"],
-        category      = data["category"],
-        price_history = data["history"],
-    )
-    return {
-        "asin":       asin,
-        "title":      data["title"],
-        "prediction": result,
-    }
-
-
-# ── 3. Demand Forecast ────────────────────────────────────────────────────────
-@router.get(
-    "/demand-forecast/{asin}",
-    summary="Forecast monthly demand for next 3 months",
-)
-def demand_forecast(
-    asin: str,
-    db:   Session = Depends(get_db),
-    _:    User    = Depends(get_current_user),
-):
-    data   = _load_product_data(asin, db)
-    result = forecast_demand(
-        bsr          = data["bsr"],
-        category     = data["category"],
-        review_count = data["review_count"],
-        rating       = data["rating"],
-        price        = data["price"],
-        history      = data["history"],
-    )
-    return {
-        "asin":     asin,
-        "title":    data["title"],
-        "forecast": result,
-    }
-
-
-# ── 4. Niche Score ────────────────────────────────────────────────────────────
-@router.get(
-    "/niche-score/{asin}",
-    summary="Calculate niche opportunity score (0-100)",
-)
-def niche_score(
-    asin: str,
-    db:   Session = Depends(get_db),
-    _:    User    = Depends(get_current_user),
-):
-    data   = _load_product_data(asin, db)
-    result = calculate_niche_score(
-        bsr           = data["bsr"],
-        review_count  = data["review_count"],
-        rating        = data["rating"],
-        price         = data["price"],
-        monthly_sales = data["monthly_sales"],
-        seller_count  = data["seller_count"],
-        is_fba        = data["is_fba"],
-        category      = data["category"],
-        price_history = data["history"],
-    )
-    return {
-        "asin":   asin,
-        "title":  data["title"],
-        "result": result,
-    }
-
-
-# ── 5. Full ML Analysis (all 4 combined) ──────────────────────────────────────
-@router.get(
-    "/full-analysis/{asin}",
-    summary="Run all 4 ML models in one request",
-)
-def full_ml_analysis(
-    asin: str,
-    db:   Session = Depends(get_db),
-    _:    User    = Depends(get_current_user),
-):
-    data = _load_product_data(asin, db)
-
-    fake_reviews = detect_fake_reviews(
-        review_count  = data["review_count"],
-        rating        = data["rating"],
-        bsr           = data["bsr"],
-        monthly_sales = data["monthly_sales"],
-        seller_count  = data["seller_count"],
-        is_fba        = data["is_fba"],
-    )
-    price_pred = predict_price(
-        current_price = data["price"],
-        bsr           = data["bsr"],
-        rating        = data["rating"],
-        review_count  = data["review_count"],
-        seller_count  = data["seller_count"],
-        category      = data["category"],
-        price_history = data["history"],
-    )
-    demand = forecast_demand(
-        bsr          = data["bsr"],
-        category     = data["category"],
-        review_count = data["review_count"],
-        rating       = data["rating"],
-        price        = data["price"],
-        history      = data["history"],
-    )
-    niche = calculate_niche_score(
-        bsr           = data["bsr"],
-        review_count  = data["review_count"],
-        rating        = data["rating"],
-        price         = data["price"],
-        monthly_sales = data["monthly_sales"],
-        seller_count  = data["seller_count"],
-        is_fba        = data["is_fba"],
-        category      = data["category"],
-        price_history = data["history"],
-    )
-
-    return {
-        "asin":  asin,
-        "title": data["title"],
-        "product_snapshot": {
-            "price":         data["price"],
-            "bsr":           data["bsr"],
-            "rating":        data["rating"],
-            "review_count":  data["review_count"],
-            "monthly_sales": data["monthly_sales"],
-            "category":      data["category"],
-        },
-        "ml_engine": "sklearn+heuristic" if _sklearn_ready() else "heuristic",
-        "ml_results": {
-            "fake_reviews":   fake_reviews,
-            "price_forecast": price_pred,
-            "demand":         demand,
-            "niche":          niche,
-        },
-    }
-
-
-def _sklearn_ready() -> bool:
-    try:
-        from app.services.ml.sklearn_engine import is_sklearn_available
-        return is_sklearn_available()
-    except Exception:
+# app/routers/ml_router.py
+# ─────────────────────────────────────────────────────────────────────────────
+# ML Analysis Router — 5 endpoints
+#   GET  /api/ml/fake-reviews/{asin}      — fake review detection
+#   GET  /api/ml/price-prediction/{asin}  — price forecast
+#   GET  /api/ml/demand-forecast/{asin}   — demand forecast
+#   GET  /api/ml/niche-score/{asin}       — niche opportunity score
+#   GET  /api/ml/full-analysis/{asin}     — all 4 combined
+# ─────────────────────────────────────────────────────────────────────────────
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.dependencies import get_current_user
+from app.models.user import User
+from app.models.product import Product, PriceHistory, TrackedProduct
+from app.services.ml.fake_review_detector import detect_fake_reviews
+from app.services.ml.price_predictor      import predict_price
+from app.services.ml.demand_forecaster    import forecast_demand
+from app.services.ml.niche_scorer         import calculate_niche_score
+
+router = APIRouter(prefix="/api/ml", tags=["ML Features"])
+
+
+# ── Helper: load product + latest data from DB ─────────────────────────────
+def _load_product_data(asin: str, db: Session) -> dict:
+    """
+    Load product and its price history from the database.
+    Returns a unified dict of all available fields.
+    Raises 404 if product not found.
+    """
+    product = db.query(Product).filter(Product.asin == asin.upper()).first()
+    if not product:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Product {asin} not found. Search for it first using GET /api/products/{asin}",
+        )
+
+    # Load price history (last 30 records)
+    history_rows = (
+        db.query(PriceHistory)
+        .filter(PriceHistory.product_id == str(product.id))
+        .order_by(PriceHistory.recorded_at.desc())
+        .limit(30)
+        .all()
+    )
+
+    # Latest snapshot
+    latest = history_rows[0] if history_rows else None
+
+    # Serialised history for ML models
+    history_list = [
+        {
+            "price":        float(h.price) if h.price else None,
+            "bsr":          h.bsr,
+            "rating":       float(h.rating) if h.rating else None,
+            "review_count": h.review_count,
+            "recorded_at":  h.recorded_at.isoformat(),
+        }
+        for h in reversed(history_rows)
+    ]
+
+    # Estimate monthly sales from BSR (reuse your existing estimator)
+    from app.services.amazon.sales_estimator import estimate_monthly_sales
+    bsr          = latest.bsr if latest else None
+    category     = product.category or ""
+    sales_data   = estimate_monthly_sales(bsr or 0, category)
+    monthly_sales = sales_data.get("monthly_units", 0)
+
+    # Price — handle PKR→USD
+    raw_price = float(latest.price) if latest and latest.price else 0.0
+    PKR_THRESHOLD = 500
+    PKR_TO_USD    = 278.0
+    price = round(raw_price / PKR_TO_USD, 2) if raw_price > PKR_THRESHOLD else raw_price
+
+    return {
+        "asin":           product.asin,
+        "title":          product.title,
+        "category":       category,
+        "is_fba":         product.is_prime,   # prime = FBA proxy
+        "is_prime":       product.is_prime,
+        "price":          price,
+        "bsr":            bsr,
+        "rating":         float(latest.rating) if latest and latest.rating else 0.0,
+        "review_count":   latest.review_count if latest else 0,
+        "in_stock":       latest.in_stock if latest else True,
+        "monthly_sales":  monthly_sales,
+        "seller_count":   product.seller_count or 1,
+        "history":        history_list,
+    }
+
+
+# ── 1. Fake Review Detection ─────────────────────────────────────────────────
+@router.get(
+    "/fake-reviews/{asin}",
+    summary="Detect fake review patterns for a product",
+)
+def fake_review_analysis(
+    asin: str,
+    db: Session = Depends(get_db),
+    _: User = Depends(get_current_user),
+):
+    data   = _load_product_data(asin, db)
+    result = detect_fake_reviews(
+        review_count  = data["review_count"],
+        rating        = data["rating"],
+        bsr           = data["bsr"],
+        monthly_sales = data["monthly_sales"],
+        seller_count  = data["seller_count"],
+        is_fba        = data["is_fba"],
+    )
+    return {
+        "asin":     asin,
+        "title":    data["title"],
+        "analysis": result,
+    }
+
+
+# ── 2. Price Prediction ───────────────────────────────────────────────────────
+@router.get(
+    "/price-prediction/{asin}",
+    summary="Predict price movement for next 30/60/90 days",
+)
+def price_prediction(
+    asin: str,
+    db:   Session = Depends(get_db),
+    _:    User    = Depends(get_current_user),
+):
+    data   = _load_product_data(asin, db)
+    result = predict_price(
+        current_price = data["price"],
+        bsr           = data["bsr"],
+        rating        = data["rating"],
+        review_count  = data["review_count"],
+        seller_count  = data["seller_count"],
+        category      = data["category"],
+        price_history = data["history"],
+    )
+    return {
+        "asin":       asin,
+        "title":      data["title"],
+        "prediction": result,
+    }
+
+
+# ── 3. Demand Forecast ────────────────────────────────────────────────────────
+@router.get(
+    "/demand-forecast/{asin}",
+    summary="Forecast monthly demand for next 3 months",
+)
+def demand_forecast(
+    asin: str,
+    db:   Session = Depends(get_db),
+    _:    User    = Depends(get_current_user),
+):
+    data   = _load_product_data(asin, db)
+    result = forecast_demand(
+        bsr          = data["bsr"],
+        category     = data["category"],
+        review_count = data["review_count"],
+        rating       = data["rating"],
+        price        = data["price"],
+        history      = data["history"],
+    )
+    return {
+        "asin":     asin,
+        "title":    data["title"],
+        "forecast": result,
+    }
+
+
+# ── 4. Niche Score ────────────────────────────────────────────────────────────
+@router.get(
+    "/niche-score/{asin}",
+    summary="Calculate niche opportunity score (0-100)",
+)
+def niche_score(
+    asin: str,
+    db:   Session = Depends(get_db),
+    _:    User    = Depends(get_current_user),
+):
+    data   = _load_product_data(asin, db)
+    result = calculate_niche_score(
+        bsr           = data["bsr"],
+        review_count  = data["review_count"],
+        rating        = data["rating"],
+        price         = data["price"],
+        monthly_sales = data["monthly_sales"],
+        seller_count  = data["seller_count"],
+        is_fba        = data["is_fba"],
+        category      = data["category"],
+        price_history = data["history"],
+    )
+    return {
+        "asin":   asin,
+        "title":  data["title"],
+        "result": result,
+    }
+
+
+# ── 5. Full ML Analysis (all 4 combined) ──────────────────────────────────────
+@router.get(
+    "/full-analysis/{asin}",
+    summary="Run all 4 ML models in one request",
+)
+def full_ml_analysis(
+    asin: str,
+    db:   Session = Depends(get_db),
+    _:    User    = Depends(get_current_user),
+):
+    data = _load_product_data(asin, db)
+
+    fake_reviews = detect_fake_reviews(
+        review_count  = data["review_count"],
+        rating        = data["rating"],
+        bsr           = data["bsr"],
+        monthly_sales = data["monthly_sales"],
+        seller_count  = data["seller_count"],
+        is_fba        = data["is_fba"],
+    )
+    price_pred = predict_price(
+        current_price = data["price"],
+        bsr           = data["bsr"],
+        rating        = data["rating"],
+        review_count  = data["review_count"],
+        seller_count  = data["seller_count"],
+        category      = data["category"],
+        price_history = data["history"],
+    )
+    demand = forecast_demand(
+        bsr          = data["bsr"],
+        category     = data["category"],
+        review_count = data["review_count"],
+        rating       = data["rating"],
+        price        = data["price"],
+        history      = data["history"],
+    )
+    niche = calculate_niche_score(
+        bsr           = data["bsr"],
+        review_count  = data["review_count"],
+        rating        = data["rating"],
+        price         = data["price"],
+        monthly_sales = data["monthly_sales"],
+        seller_count  = data["seller_count"],
+        is_fba        = data["is_fba"],
+        category      = data["category"],
+        price_history = data["history"],
+    )
+
+    return {
+        "asin":  asin,
+        "title": data["title"],
+        "product_snapshot": {
+            "price":         data["price"],
+            "bsr":           data["bsr"],
+            "rating":        data["rating"],
+            "review_count":  data["review_count"],
+            "monthly_sales": data["monthly_sales"],
+            "category":      data["category"],
+        },
+        "ml_engine": "sklearn+heuristic" if _sklearn_ready() else "heuristic",
+        "ml_results": {
+            "fake_reviews":   fake_reviews,
+            "price_forecast": price_pred,
+            "demand":         demand,
+            "niche":          niche,
+        },
+    }
+
+
+def _sklearn_ready() -> bool:
+    try:
+        from app.services.ml.sklearn_engine import is_sklearn_available
+        return is_sklearn_available()
+    except Exception:
         return False

app/routers/products.py

@@ -1,233 +1,233 @@
-import uuid
-from datetime import datetime, timezone
-
-from fastapi import APIRouter, Depends, HTTPException, Query, Request
-from sqlalchemy.orm import Session
-
-from app.database import get_db
-from app.dependencies import get_current_user, enforce_search_limit
-from app.models.user import User
-from app.models.product import Product, PriceHistory, TrackedProduct
-from app.services.product_service import fetch_and_sync_product, build_response
-from app.services.analytics.buy_box_history import build_buy_box_history_payload
-from app.services.amazon.product_scraper import search_asin_by_keyword
-from app.services.amazon.keyword_service import get_amazon_suggestions
-from app.services.supplier_service import find_suppliers
-from app.utils.validators import normalize_asin
-from app.security.input_guard import scan_user_text
-from app.security.rate_limit import enforce_scrape_rate_limit
-
-router = APIRouter(prefix="/api/products", tags=["Products"])
-
-
-@router.get("/search/text")
-def search_by_keyword(
-    q: str = Query(..., min_length=2, max_length=120),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    """Resolve a keyword to an ASIN via Amazon search, with autocomplete suggestions."""
-    enforce_search_limit(current_user, db)
-    q = scan_user_text(q.strip(), "search query")
-    asin = search_asin_by_keyword(q)
-    suggestions = get_amazon_suggestions(q)
-    if not asin and suggestions:
-        asin = search_asin_by_keyword(suggestions[0])
-    if not asin:
-        raise HTTPException(status_code=404, detail="No products found for that keyword")
-    asin = normalize_asin(asin)
-    result = fetch_and_sync_product(db, asin, force=True)
-    if not result:
-        raise HTTPException(status_code=404, detail="Product not found")
-    result["matched_keyword"] = q
-    result["suggestions"] = suggestions[:8]
-    return result
-
-
-@router.get("/tracked/list")
-def get_tracked(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    tracked_list = db.query(TrackedProduct).filter(TrackedProduct.user_id == str(current_user.id)).all()
-    result = []
-    for t in tracked_list:
-        product = db.query(Product).filter(Product.id == t.product_id).first()
-        if product:
-            latest = (
-                db.query(PriceHistory)
-                .filter(PriceHistory.product_id == product.id)
-                .order_by(PriceHistory.recorded_at.desc())
-                .first()
-            )
-            from app.services.amazon.sales_estimator import estimate_monthly_sales
-            sales_data = estimate_monthly_sales(latest.bsr if latest else 0, product.category or "")
-            price_val = float(latest.price) if latest and latest.price else None
-            result.append({
-                "asin": product.asin,
-                "title": product.title,
-                "brand": product.brand,
-                "upc": product.upc,
-                "image_url": product.image_url,
-                "is_prime": product.is_prime,
-                "has_buy_box": product.has_buy_box if product.has_buy_box is not None else True,
-                "buy_box_winner": product.buy_box_winner,
-                "buy_box_price": float(product.buy_box_price) if product.buy_box_price else None,
-                "buy_box_is_fba": product.buy_box_is_fba,
-                "is_amazon_sold": product.is_amazon_sold or False,
-                "seller_count": product.seller_count or 1,
-                "current_price": float(latest.price) if latest and latest.price else None,
-                "current_bsr": latest.bsr if latest else None,
-                "current_rating": float(latest.rating) if latest and latest.rating else None,
-                "current_review_count": latest.review_count if latest else None,
-                "sales_estimate_monthly": sales_data["monthly_units"],
-                "revenue_estimate_monthly": round(sales_data["monthly_units"] * price_val, 2) if sales_data["monthly_units"] and price_val else None,
-                "data_source": product.last_data_source or "cached",
-                "last_synced_at": product.last_synced_at.isoformat() if product.last_synced_at else None,
-                "tracked_at": t.tracked_at.isoformat() if t.tracked_at else datetime.now(timezone.utc).isoformat(),
-            })
-    return result
-
-
-@router.get("/{asin}")
-def get_product(
-    asin: str,
-    request: Request,
-    refresh: bool = Query(False),
-    quick: bool = Query(False),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    asin = normalize_asin(asin)
-    if refresh:
-        enforce_scrape_rate_limit(str(current_user.id), request)
-    product = db.query(Product).filter(Product.asin == asin).first()
-
-    if quick:
-        if product:
-            from app.services.product_service import build_response
-            return build_response(db, product, product.last_data_source or "cached")
-        raise HTTPException(status_code=404, detail="Product not cached yet")
-
-    needs_scrape = refresh or not product
-
-    if not needs_scrape and product.last_synced_at:
-        last_synced = product.last_synced_at
-        if last_synced.tzinfo is None:
-            last_synced = last_synced.replace(tzinfo=timezone.utc)
-        age_hours = (datetime.now(timezone.utc) - last_synced).total_seconds() / 3600
-        needs_scrape = age_hours > 6
-
-    if needs_scrape:
-        enforce_search_limit(current_user, db)
-
-    result = fetch_and_sync_product(db, asin, force=refresh)
-    if not result:
-        raise HTTPException(status_code=404, detail="Product not found")
-    return result
-
-
-@router.get("/{asin}/buy-box/history")
-def get_buy_box_history(
-    asin: str,
-    days: int = Query(30, ge=7, le=365),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    asin = normalize_asin(asin)
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        raise HTTPException(status_code=404, detail="Product not found")
-
-    latest = (
-        db.query(PriceHistory)
-        .filter(PriceHistory.product_id == product.id)
-        .order_by(PriceHistory.recorded_at.desc())
-        .limit(180)
-        .all()
-    )
-    price_history_rows = [
-        {
-            "price": float(h.price) if h.price else None,
-            "bsr": h.bsr,
-            "rating": float(h.rating) if h.rating else None,
-            "review_count": h.review_count,
-            "recorded_at": h.recorded_at.isoformat(),
-        }
-        for h in reversed(latest)
-    ]
-    price = float(latest[0].price) if latest and latest[0].price else None
-    fallback = {
-        "buy_box_winner": product.buy_box_winner,
-        "buy_box_price": float(product.buy_box_price) if product.buy_box_price else price,
-        "buy_box_is_fba": product.buy_box_is_fba,
-        "is_amazon_sold": product.is_amazon_sold or False,
-        "seller_count": product.seller_count or 1,
-        "has_buy_box": product.has_buy_box if product.has_buy_box is not None else True,
-        "price": price,
-        "other_sellers": [],
-        "category": product.category or "default",
-        "price_history": price_history_rows,
-    }
-    return build_buy_box_history_payload(db, str(product.id), range_days=days, fallback_data=fallback)
-
-
-@router.get("/{asin}/suppliers")
-def get_product_suppliers(
-    asin: str,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    asin = normalize_asin(asin)
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        raise HTTPException(status_code=404, detail="Product not found")
-    return find_suppliers(product.title or "", product.brand or "", asin)
-
-
-@router.post("/{asin}/refresh")
-def refresh_product(
-    asin: str,
-    request: Request,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    asin = normalize_asin(asin)
-    enforce_scrape_rate_limit(str(current_user.id), request)
-    enforce_search_limit(current_user, db)
-    result = fetch_and_sync_product(db, asin, force=True)
-    if not result:
-        raise HTTPException(status_code=404, detail="Product not found")
-    return result
-
-
-@router.post("/{asin}/track")
-def track_product(asin: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    asin = normalize_asin(asin)
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        raise HTTPException(status_code=404, detail="Fetch product first")
-    existing = db.query(TrackedProduct).filter(
-        TrackedProduct.user_id == str(current_user.id),
-        TrackedProduct.product_id == str(product.id),
-    ).first()
-    if existing:
-        raise HTTPException(status_code=400, detail="Already tracking")
-    tracked = TrackedProduct(id=str(uuid.uuid4()), user_id=str(current_user.id), product_id=str(product.id))
-    db.add(tracked)
-    db.commit()
-    return {"message": "Product tracked!", "asin": asin}
-
-
-@router.delete("/{asin}/track")
-def untrack_product(asin: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
-    asin = normalize_asin(asin)
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        raise HTTPException(status_code=404, detail="Product not found")
-    tracked = db.query(TrackedProduct).filter(
-        TrackedProduct.user_id == str(current_user.id),
-        TrackedProduct.product_id == str(product.id),
-    ).first()
-    if not tracked:
-        raise HTTPException(status_code=404, detail="Not tracking this product")
-    db.delete(tracked)
-    db.commit()
-    return {"message": "Untracked successfully"}
+import uuid
+from datetime import datetime, timezone
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from sqlalchemy.orm import Session
+
+from app.database import get_db
+from app.dependencies import get_current_user, enforce_search_limit
+from app.models.user import User
+from app.models.product import Product, PriceHistory, TrackedProduct
+from app.services.product_service import fetch_and_sync_product, build_response
+from app.services.analytics.buy_box_history import build_buy_box_history_payload
+from app.services.amazon.product_scraper import search_asin_by_keyword
+from app.services.amazon.keyword_service import get_amazon_suggestions
+from app.services.supplier_service import find_suppliers
+from app.utils.validators import normalize_asin
+from app.security.input_guard import scan_user_text
+from app.security.rate_limit import enforce_scrape_rate_limit
+
+router = APIRouter(prefix="/api/products", tags=["Products"])
+
+
+@router.get("/search/text")
+def search_by_keyword(
+    q: str = Query(..., min_length=2, max_length=120),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    """Resolve a keyword to an ASIN via Amazon search, with autocomplete suggestions."""
+    enforce_search_limit(current_user, db)
+    q = scan_user_text(q.strip(), "search query")
+    asin = search_asin_by_keyword(q)
+    suggestions = get_amazon_suggestions(q)
+    if not asin and suggestions:
+        asin = search_asin_by_keyword(suggestions[0])
+    if not asin:
+        raise HTTPException(status_code=404, detail="No products found for that keyword")
+    asin = normalize_asin(asin)
+    result = fetch_and_sync_product(db, asin, force=True)
+    if not result:
+        raise HTTPException(status_code=404, detail="Product not found")
+    result["matched_keyword"] = q
+    result["suggestions"] = suggestions[:8]
+    return result
+
+
+@router.get("/tracked/list")
+def get_tracked(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    tracked_list = db.query(TrackedProduct).filter(TrackedProduct.user_id == str(current_user.id)).all()
+    result = []
+    for t in tracked_list:
+        product = db.query(Product).filter(Product.id == t.product_id).first()
+        if product:
+            latest = (
+                db.query(PriceHistory)
+                .filter(PriceHistory.product_id == product.id)
+                .order_by(PriceHistory.recorded_at.desc())
+                .first()
+            )
+            from app.services.amazon.sales_estimator import estimate_monthly_sales
+            sales_data = estimate_monthly_sales(latest.bsr if latest else 0, product.category or "")
+            price_val = float(latest.price) if latest and latest.price else None
+            result.append({
+                "asin": product.asin,
+                "title": product.title,
+                "brand": product.brand,
+                "upc": product.upc,
+                "image_url": product.image_url,
+                "is_prime": product.is_prime,
+                "has_buy_box": product.has_buy_box if product.has_buy_box is not None else True,
+                "buy_box_winner": product.buy_box_winner,
+                "buy_box_price": float(product.buy_box_price) if product.buy_box_price else None,
+                "buy_box_is_fba": product.buy_box_is_fba,
+                "is_amazon_sold": product.is_amazon_sold or False,
+                "seller_count": product.seller_count or 1,
+                "current_price": float(latest.price) if latest and latest.price else None,
+                "current_bsr": latest.bsr if latest else None,
+                "current_rating": float(latest.rating) if latest and latest.rating else None,
+                "current_review_count": latest.review_count if latest else None,
+                "sales_estimate_monthly": sales_data["monthly_units"],
+                "revenue_estimate_monthly": round(sales_data["monthly_units"] * price_val, 2) if sales_data["monthly_units"] and price_val else None,
+                "data_source": product.last_data_source or "cached",
+                "last_synced_at": product.last_synced_at.isoformat() if product.last_synced_at else None,
+                "tracked_at": t.tracked_at.isoformat() if t.tracked_at else datetime.now(timezone.utc).isoformat(),
+            })
+    return result
+
+
+@router.get("/{asin}")
+def get_product(
+    asin: str,
+    request: Request,
+    refresh: bool = Query(False),
+    quick: bool = Query(False),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    asin = normalize_asin(asin)
+    if refresh:
+        enforce_scrape_rate_limit(str(current_user.id), request)
+    product = db.query(Product).filter(Product.asin == asin).first()
+
+    if quick:
+        if product:
+            from app.services.product_service import build_response
+            return build_response(db, product, product.last_data_source or "cached")
+        raise HTTPException(status_code=404, detail="Product not cached yet")
+
+    needs_scrape = refresh or not product
+
+    if not needs_scrape and product.last_synced_at:
+        last_synced = product.last_synced_at
+        if last_synced.tzinfo is None:
+            last_synced = last_synced.replace(tzinfo=timezone.utc)
+        age_hours = (datetime.now(timezone.utc) - last_synced).total_seconds() / 3600
+        needs_scrape = age_hours > 6
+
+    if needs_scrape:
+        enforce_search_limit(current_user, db)
+
+    result = fetch_and_sync_product(db, asin, force=refresh)
+    if not result:
+        raise HTTPException(status_code=404, detail="Product not found")
+    return result
+
+
+@router.get("/{asin}/buy-box/history")
+def get_buy_box_history(
+    asin: str,
+    days: int = Query(30, ge=7, le=365),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    asin = normalize_asin(asin)
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found")
+
+    latest = (
+        db.query(PriceHistory)
+        .filter(PriceHistory.product_id == product.id)
+        .order_by(PriceHistory.recorded_at.desc())
+        .limit(180)
+        .all()
+    )
+    price_history_rows = [
+        {
+            "price": float(h.price) if h.price else None,
+            "bsr": h.bsr,
+            "rating": float(h.rating) if h.rating else None,
+            "review_count": h.review_count,
+            "recorded_at": h.recorded_at.isoformat(),
+        }
+        for h in reversed(latest)
+    ]
+    price = float(latest[0].price) if latest and latest[0].price else None
+    fallback = {
+        "buy_box_winner": product.buy_box_winner,
+        "buy_box_price": float(product.buy_box_price) if product.buy_box_price else price,
+        "buy_box_is_fba": product.buy_box_is_fba,
+        "is_amazon_sold": product.is_amazon_sold or False,
+        "seller_count": product.seller_count or 1,
+        "has_buy_box": product.has_buy_box if product.has_buy_box is not None else True,
+        "price": price,
+        "other_sellers": [],
+        "category": product.category or "default",
+        "price_history": price_history_rows,
+    }
+    return build_buy_box_history_payload(db, str(product.id), range_days=days, fallback_data=fallback)
+
+
+@router.get("/{asin}/suppliers")
+def get_product_suppliers(
+    asin: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    asin = normalize_asin(asin)
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found")
+    return find_suppliers(product.title or "", product.brand or "", asin)
+
+
+@router.post("/{asin}/refresh")
+def refresh_product(
+    asin: str,
+    request: Request,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    asin = normalize_asin(asin)
+    enforce_scrape_rate_limit(str(current_user.id), request)
+    enforce_search_limit(current_user, db)
+    result = fetch_and_sync_product(db, asin, force=True)
+    if not result:
+        raise HTTPException(status_code=404, detail="Product not found")
+    return result
+
+
+@router.post("/{asin}/track")
+def track_product(asin: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    asin = normalize_asin(asin)
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        raise HTTPException(status_code=404, detail="Fetch product first")
+    existing = db.query(TrackedProduct).filter(
+        TrackedProduct.user_id == str(current_user.id),
+        TrackedProduct.product_id == str(product.id),
+    ).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Already tracking")
+    tracked = TrackedProduct(id=str(uuid.uuid4()), user_id=str(current_user.id), product_id=str(product.id))
+    db.add(tracked)
+    db.commit()
+    return {"message": "Product tracked!", "asin": asin}
+
+
+@router.delete("/{asin}/track")
+def untrack_product(asin: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    asin = normalize_asin(asin)
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found")
+    tracked = db.query(TrackedProduct).filter(
+        TrackedProduct.user_id == str(current_user.id),
+        TrackedProduct.product_id == str(product.id),
+    ).first()
+    if not tracked:
+        raise HTTPException(status_code=404, detail="Not tracking this product")
+    db.delete(tracked)
+    db.commit()
+    return {"message": "Untracked successfully"}

app/routers/profit.py

@@ -1,176 +1,176 @@
-from fastapi import APIRouter, Depends, Query
-from app.dependencies import get_current_user
-from app.models.user import User
-from app.services.analytics.profit_calculator import calculate_profit, compare_fba_fbm, calculate_storage_cost_per_unit
-from sqlalchemy.orm import Session
-from app.database import get_db
-from app.models.product import Product, PriceHistory
-
-router = APIRouter(prefix="/api/profit", tags=["Profit Calculator"])
-
-
-@router.get("/calculate")
-def profit_calculator(
-    selling_price: float = Query(...),
-    product_cost: float = Query(...),
-    category: str = Query(default="default"),
-    weight_lbs: float = Query(default=1.0),
-    shipping_to_fba: float = Query(default=0.56),
-    fulfillment_mode: str = Query(default="fba"),
-    fbm_fulfillment_cost: float = Query(default=0.0),
-    storage_monthly_per_unit: float = Query(default=0.0),
-    avg_inventory_units: float = Query(default=1.0),
-    monthly_units_sold: float = Query(default=1.0),
-    misc_cost: float = Query(default=0.0),
-    shipping_charge: float = Query(default=0.0),
-    estimated_units: int = Query(default=1),
-    current_user: User = Depends(get_current_user),
-):
-    storage = calculate_storage_cost_per_unit(storage_monthly_per_unit, avg_inventory_units, monthly_units_sold)
-    mode = "fbm" if fulfillment_mode.lower() == "fbm" else "fba"
-    return calculate_profit(
-        selling_price=selling_price,
-        product_cost=product_cost,
-        category=category,
-        weight_lbs=weight_lbs,
-        shipping_to_fba=shipping_to_fba,
-        additional_costs=misc_cost,
-        fulfillment_mode=mode,
-        fbm_fulfillment_cost=fbm_fulfillment_cost,
-        storage_cost_per_unit=storage,
-        shipping_charge=shipping_charge,
-        estimated_units=estimated_units,
-    )
-
-
-@router.get("/compare")
-def profit_compare_fba_fbm(
-    selling_price: float = Query(...),
-    product_cost: float = Query(...),
-    category: str = Query(default="default"),
-    weight_lbs: float = Query(default=1.0),
-    shipping_to_fba: float = Query(default=0.0),
-    fbm_fulfillment_cost: float = Query(default=0.0),
-    storage_monthly_fba: float = Query(default=0.0),
-    storage_monthly_fbm: float = Query(default=0.0),
-    avg_inventory_units: float = Query(default=1.0),
-    monthly_units_sold: float = Query(default=1.0),
-    misc_cost: float = Query(default=0.0),
-    shipping_charge: float = Query(default=0.0),
-    estimated_units: int = Query(default=1),
-    season: str = Query(default="standard", description="standard=Jan-Sep, peak=Oct-Dec"),
-    inbound_region: str = Query(default="west"),
-    units_per_shipment: int = Query(default=1),
-    removal_units: int = Query(default=0),
-    disposal_units: int = Query(default=0),
-    current_user: User = Depends(get_current_user),
-):
-    season_key = "peak" if season.lower() == "peak" else "standard"
-    storage_fba = calculate_storage_cost_per_unit(storage_monthly_fba, avg_inventory_units, monthly_units_sold)
-    storage_fbm = calculate_storage_cost_per_unit(storage_monthly_fbm, avg_inventory_units, monthly_units_sold)
-    return compare_fba_fbm(
-        selling_price=selling_price,
-        product_cost=product_cost,
-        category=category,
-        weight_lbs=weight_lbs,
-        shipping_to_fba=shipping_to_fba,
-        fbm_fulfillment_cost=fbm_fulfillment_cost,
-        storage_cost_per_unit_fba=storage_fba,
-        storage_cost_per_unit_fbm=storage_fbm,
-        misc_cost=misc_cost,
-        shipping_charge=shipping_charge,
-        estimated_units=estimated_units,
-        season=season_key,
-        inbound_region=inbound_region,
-        avg_inventory_units=avg_inventory_units,
-        monthly_units_sold=monthly_units_sold,
-        units_per_shipment=units_per_shipment,
-        removal_units=removal_units,
-        disposal_units=disposal_units,
-    )
-
-
-@router.get("/history/{asin}")
-def profit_history(
-    asin: str,
-    product_cost: float = Query(default=0.0),
-    misc_cost: float = Query(default=0.0),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    from app.services.analytics.profit_calculator import build_profit_history_series
-
-    product = db.query(Product).filter(Product.asin == asin.upper()).first()
-    if not product:
-        return {"error": "Product not found"}
-    history = (
-        db.query(PriceHistory)
-        .filter(PriceHistory.product_id == product.id)
-        .order_by(PriceHistory.recorded_at.asc())
-        .limit(500)
-        .all()
-    )
-    rows = [
-        {
-            "price": float(h.price) if h.price else None,
-            "bsr": h.bsr,
-            "recorded_at": h.recorded_at.isoformat(),
-        }
-        for h in history
-    ]
-    weight = float(product.package_weight_lbs) if product.package_weight_lbs else 1.0
-    return {
-        "asin": asin,
-        "series": build_profit_history_series(rows, product.category or "default", weight, product_cost, misc_cost),
-    }
-
-
-@router.get("/{asin}")
-def profit_for_product(
-    asin: str,
-    product_cost: float = Query(..., description="Your cost to source the product"),
-    selling_price: float | None = Query(default=None, description="Override selling price (editable)"),
-    weight_lbs: float = Query(default=1.0),
-    shipping_to_fba: float = Query(default=0.56),
-    fulfillment_mode: str = Query(default="fba"),
-    fbm_fulfillment_cost: float = Query(default=0.0),
-    misc_cost: float = Query(default=0.0),
-    shipping_charge: float = Query(default=0.0),
-    estimated_units: int = Query(default=1),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    product = db.query(Product).filter(Product.asin == asin.upper()).first()
-    if not product:
-        return {"error": "Product not found"}
-
-    latest = (
-        db.query(PriceHistory)
-        .filter(PriceHistory.product_id == product.id)
-        .order_by(PriceHistory.recorded_at.desc())
-        .first()
-    )
-
-    price = selling_price
-    if price is None:
-        if not latest or not latest.price:
-            return {"error": "No price data available"}
-        price = float(latest.price)
-
-    mode = "fbm" if fulfillment_mode.lower() == "fbm" else "fba"
-    result = calculate_profit(
-        selling_price=float(price),
-        product_cost=product_cost,
-        category=product.category or "default",
-        weight_lbs=weight_lbs,
-        shipping_to_fba=shipping_to_fba,
-        additional_costs=misc_cost,
-        fulfillment_mode=mode,
-        fbm_fulfillment_cost=fbm_fulfillment_cost,
-        shipping_charge=shipping_charge,
-        estimated_units=estimated_units,
-    )
-
-    result["asin"] = asin
-    result["product_title"] = product.title
-    return result
+from fastapi import APIRouter, Depends, Query
+from app.dependencies import get_current_user
+from app.models.user import User
+from app.services.analytics.profit_calculator import calculate_profit, compare_fba_fbm, calculate_storage_cost_per_unit
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.models.product import Product, PriceHistory
+
+router = APIRouter(prefix="/api/profit", tags=["Profit Calculator"])
+
+
+@router.get("/calculate")
+def profit_calculator(
+    selling_price: float = Query(...),
+    product_cost: float = Query(...),
+    category: str = Query(default="default"),
+    weight_lbs: float = Query(default=1.0),
+    shipping_to_fba: float = Query(default=0.56),
+    fulfillment_mode: str = Query(default="fba"),
+    fbm_fulfillment_cost: float = Query(default=0.0),
+    storage_monthly_per_unit: float = Query(default=0.0),
+    avg_inventory_units: float = Query(default=1.0),
+    monthly_units_sold: float = Query(default=1.0),
+    misc_cost: float = Query(default=0.0),
+    shipping_charge: float = Query(default=0.0),
+    estimated_units: int = Query(default=1),
+    current_user: User = Depends(get_current_user),
+):
+    storage = calculate_storage_cost_per_unit(storage_monthly_per_unit, avg_inventory_units, monthly_units_sold)
+    mode = "fbm" if fulfillment_mode.lower() == "fbm" else "fba"
+    return calculate_profit(
+        selling_price=selling_price,
+        product_cost=product_cost,
+        category=category,
+        weight_lbs=weight_lbs,
+        shipping_to_fba=shipping_to_fba,
+        additional_costs=misc_cost,
+        fulfillment_mode=mode,
+        fbm_fulfillment_cost=fbm_fulfillment_cost,
+        storage_cost_per_unit=storage,
+        shipping_charge=shipping_charge,
+        estimated_units=estimated_units,
+    )
+
+
+@router.get("/compare")
+def profit_compare_fba_fbm(
+    selling_price: float = Query(...),
+    product_cost: float = Query(...),
+    category: str = Query(default="default"),
+    weight_lbs: float = Query(default=1.0),
+    shipping_to_fba: float = Query(default=0.0),
+    fbm_fulfillment_cost: float = Query(default=0.0),
+    storage_monthly_fba: float = Query(default=0.0),
+    storage_monthly_fbm: float = Query(default=0.0),
+    avg_inventory_units: float = Query(default=1.0),
+    monthly_units_sold: float = Query(default=1.0),
+    misc_cost: float = Query(default=0.0),
+    shipping_charge: float = Query(default=0.0),
+    estimated_units: int = Query(default=1),
+    season: str = Query(default="standard", description="standard=Jan-Sep, peak=Oct-Dec"),
+    inbound_region: str = Query(default="west"),
+    units_per_shipment: int = Query(default=1),
+    removal_units: int = Query(default=0),
+    disposal_units: int = Query(default=0),
+    current_user: User = Depends(get_current_user),
+):
+    season_key = "peak" if season.lower() == "peak" else "standard"
+    storage_fba = calculate_storage_cost_per_unit(storage_monthly_fba, avg_inventory_units, monthly_units_sold)
+    storage_fbm = calculate_storage_cost_per_unit(storage_monthly_fbm, avg_inventory_units, monthly_units_sold)
+    return compare_fba_fbm(
+        selling_price=selling_price,
+        product_cost=product_cost,
+        category=category,
+        weight_lbs=weight_lbs,
+        shipping_to_fba=shipping_to_fba,
+        fbm_fulfillment_cost=fbm_fulfillment_cost,
+        storage_cost_per_unit_fba=storage_fba,
+        storage_cost_per_unit_fbm=storage_fbm,
+        misc_cost=misc_cost,
+        shipping_charge=shipping_charge,
+        estimated_units=estimated_units,
+        season=season_key,
+        inbound_region=inbound_region,
+        avg_inventory_units=avg_inventory_units,
+        monthly_units_sold=monthly_units_sold,
+        units_per_shipment=units_per_shipment,
+        removal_units=removal_units,
+        disposal_units=disposal_units,
+    )
+
+
+@router.get("/history/{asin}")
+def profit_history(
+    asin: str,
+    product_cost: float = Query(default=0.0),
+    misc_cost: float = Query(default=0.0),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    from app.services.analytics.profit_calculator import build_profit_history_series
+
+    product = db.query(Product).filter(Product.asin == asin.upper()).first()
+    if not product:
+        return {"error": "Product not found"}
+    history = (
+        db.query(PriceHistory)
+        .filter(PriceHistory.product_id == product.id)
+        .order_by(PriceHistory.recorded_at.asc())
+        .limit(500)
+        .all()
+    )
+    rows = [
+        {
+            "price": float(h.price) if h.price else None,
+            "bsr": h.bsr,
+            "recorded_at": h.recorded_at.isoformat(),
+        }
+        for h in history
+    ]
+    weight = float(product.package_weight_lbs) if product.package_weight_lbs else 1.0
+    return {
+        "asin": asin,
+        "series": build_profit_history_series(rows, product.category or "default", weight, product_cost, misc_cost),
+    }
+
+
+@router.get("/{asin}")
+def profit_for_product(
+    asin: str,
+    product_cost: float = Query(..., description="Your cost to source the product"),
+    selling_price: float | None = Query(default=None, description="Override selling price (editable)"),
+    weight_lbs: float = Query(default=1.0),
+    shipping_to_fba: float = Query(default=0.56),
+    fulfillment_mode: str = Query(default="fba"),
+    fbm_fulfillment_cost: float = Query(default=0.0),
+    misc_cost: float = Query(default=0.0),
+    shipping_charge: float = Query(default=0.0),
+    estimated_units: int = Query(default=1),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+):
+    product = db.query(Product).filter(Product.asin == asin.upper()).first()
+    if not product:
+        return {"error": "Product not found"}
+
+    latest = (
+        db.query(PriceHistory)
+        .filter(PriceHistory.product_id == product.id)
+        .order_by(PriceHistory.recorded_at.desc())
+        .first()
+    )
+
+    price = selling_price
+    if price is None:
+        if not latest or not latest.price:
+            return {"error": "No price data available"}
+        price = float(latest.price)
+
+    mode = "fbm" if fulfillment_mode.lower() == "fbm" else "fba"
+    result = calculate_profit(
+        selling_price=float(price),
+        product_cost=product_cost,
+        category=product.category or "default",
+        weight_lbs=weight_lbs,
+        shipping_to_fba=shipping_to_fba,
+        additional_costs=misc_cost,
+        fulfillment_mode=mode,
+        fbm_fulfillment_cost=fbm_fulfillment_cost,
+        shipping_charge=shipping_charge,
+        estimated_units=estimated_units,
+    )
+
+    result["asin"] = asin
+    result["product_title"] = product.title
+    return result

app/schemas/user.py

@@ -1,31 +1,31 @@
-from pydantic import BaseModel, EmailStr, Field
-from typing import Optional
-from datetime import datetime
-import uuid
-
-class UserRegister(BaseModel):
-    email: EmailStr
-    password: str = Field(min_length=8, max_length=128)
-    full_name: Optional[str] = Field(default=None, max_length=120)
-
-class UserLogin(BaseModel):
-    email: EmailStr
-    password: str = Field(min_length=1, max_length=128)
-
-class UserResponse(BaseModel):
-    id: uuid.UUID
-    email: str
-    full_name: Optional[str]
-    plan: str
-    created_at: datetime
-
-    class Config:
-        from_attributes = True
-
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-    user: UserResponse
-
-class LogoutResponse(BaseModel):
-    message: str
+from pydantic import BaseModel, EmailStr, Field
+from typing import Optional
+from datetime import datetime
+import uuid
+
+class UserRegister(BaseModel):
+    email: EmailStr
+    password: str = Field(min_length=8, max_length=128)
+    full_name: Optional[str] = Field(default=None, max_length=120)
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str = Field(min_length=1, max_length=128)
+
+class UserResponse(BaseModel):
+    id: uuid.UUID
+    email: str
+    full_name: Optional[str]
+    plan: str
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+    user: UserResponse
+
+class LogoutResponse(BaseModel):
+    message: str

app/security/__init__.py

@@ -1 +1 @@
-"""Rankora security helpers — SSTI, ReDoS, injection, replay, and rate-limit guards."""
+"""Rankora security helpers — SSTI, ReDoS, injection, replay, and rate-limit guards."""

app/security/input_guard.py

@@ -1,83 +1,83 @@
-"""Input validation: SSTI, SQL/NoSQL injection probes, ReDoS-safe string handling."""
-import re
-from fastapi import HTTPException
-
-# Max sizes — long-password DoS / payload abuse
-MAX_PASSWORD_CHARS = 128
-MAX_PASSWORD_BYTES = 72  # bcrypt limit
-MAX_TEXT_FIELD = 8_000
-MAX_EMAIL_LEN = 254
-MAX_NAME_LEN = 120
-MAX_QUERY_LEN = 500
-
-# SSTI / template injection probes (Jinja, Twig, ERB, etc.)
-_SSTI = re.compile(
-    r"(\{\{|\}\}|{%|%}|#\{|<%|<\?|\$\{|\[\[|\]\]|"
-    r"__class__|__mro__|__subclasses__|__globals__|"
-    r"config\.|request\.|self\.)",
-    re.IGNORECASE,
-)
-
-# Common SQL / NoSQL injection signatures in user text
-_INJECTION = re.compile(
-    r"(\bUNION\b\s+\bSELECT\b|\bDROP\b\s+\bTABLE\b|\bINSERT\b\s+\bINTO\b|"
-    r"\bOR\b\s+['\"]?\d+['\"]?\s*=\s*['\"]?\d+|"
-    r"\$where|\$gt|\$ne|\$regex|\{\s*\"\$)",
-    re.IGNORECASE,
-)
-
-# Safe bounded patterns only
-_ASIN = re.compile(r"^[A-Z0-9]{10}$")
-
-
-def assert_password_safe(password: str) -> None:
-    """Block long-password DoS before bcrypt."""
-    if not password:
-        raise HTTPException(status_code=400, detail="Password is required")
-    if len(password) < 8:
-        raise HTTPException(status_code=400, detail="Password must be at least 8 characters")
-    if len(password) > MAX_PASSWORD_CHARS:
-        raise HTTPException(status_code=400, detail=f"Password must be at most {MAX_PASSWORD_CHARS} characters")
-    if len(password.encode("utf-8")) > MAX_PASSWORD_BYTES:
-        raise HTTPException(status_code=400, detail="Password is too long for secure hashing")
-
-
-def clamp_str(value: str | None, max_len: int, field: str = "field") -> str:
-    if value is None:
-        return ""
-    if not isinstance(value, str):
-        raise HTTPException(status_code=400, detail=f"Invalid {field}")
-    if len(value) > max_len:
-        raise HTTPException(status_code=400, detail=f"{field} exceeds maximum length ({max_len})")
-    return value
-
-
-def scan_user_text(value: str, field: str = "input") -> str:
-    """Reject SSTI and injection probe strings in free-text fields."""
-    value = clamp_str(value, MAX_TEXT_FIELD, field)
-    if _SSTI.search(value):
-        raise HTTPException(status_code=400, detail="Invalid characters in request (template injection blocked)")
-    if _INJECTION.search(value):
-        raise HTTPException(status_code=400, detail="Invalid characters in request (injection blocked)")
-    return value
-
-
-def strip_for_regex(text: str, max_len: int = 500) -> str:
-    """ReDoS-safe prep: cap length before regex; strip without nested backtracking."""
-    if not text:
-        return ""
-    text = text[:max_len]
-    # Simple character removal instead of heavy regex on long strings
-    out = []
-    for ch in text:
-        if ch in "()[]":
-            continue
-        out.append(ch)
-    return "".join(out)
-
-
-def normalize_asin_safe(asin: str) -> str:
-    cleaned = (asin or "").upper().strip()[:16]
-    if not _ASIN.match(cleaned):
-        raise HTTPException(status_code=400, detail="Invalid ASIN — must be 10 alphanumeric characters")
-    return cleaned
+"""Input validation: SSTI, SQL/NoSQL injection probes, ReDoS-safe string handling."""
+import re
+from fastapi import HTTPException
+
+# Max sizes — long-password DoS / payload abuse
+MAX_PASSWORD_CHARS = 128
+MAX_PASSWORD_BYTES = 72  # bcrypt limit
+MAX_TEXT_FIELD = 8_000
+MAX_EMAIL_LEN = 254
+MAX_NAME_LEN = 120
+MAX_QUERY_LEN = 500
+
+# SSTI / template injection probes (Jinja, Twig, ERB, etc.)
+_SSTI = re.compile(
+    r"(\{\{|\}\}|{%|%}|#\{|<%|<\?|\$\{|\[\[|\]\]|"
+    r"__class__|__mro__|__subclasses__|__globals__|"
+    r"config\.|request\.|self\.)",
+    re.IGNORECASE,
+)
+
+# Common SQL / NoSQL injection signatures in user text
+_INJECTION = re.compile(
+    r"(\bUNION\b\s+\bSELECT\b|\bDROP\b\s+\bTABLE\b|\bINSERT\b\s+\bINTO\b|"
+    r"\bOR\b\s+['\"]?\d+['\"]?\s*=\s*['\"]?\d+|"
+    r"\$where|\$gt|\$ne|\$regex|\{\s*\"\$)",
+    re.IGNORECASE,
+)
+
+# Safe bounded patterns only
+_ASIN = re.compile(r"^[A-Z0-9]{10}$")
+
+
+def assert_password_safe(password: str) -> None:
+    """Block long-password DoS before bcrypt."""
+    if not password:
+        raise HTTPException(status_code=400, detail="Password is required")
+    if len(password) < 8:
+        raise HTTPException(status_code=400, detail="Password must be at least 8 characters")
+    if len(password) > MAX_PASSWORD_CHARS:
+        raise HTTPException(status_code=400, detail=f"Password must be at most {MAX_PASSWORD_CHARS} characters")
+    if len(password.encode("utf-8")) > MAX_PASSWORD_BYTES:
+        raise HTTPException(status_code=400, detail="Password is too long for secure hashing")
+
+
+def clamp_str(value: str | None, max_len: int, field: str = "field") -> str:
+    if value is None:
+        return ""
+    if not isinstance(value, str):
+        raise HTTPException(status_code=400, detail=f"Invalid {field}")
+    if len(value) > max_len:
+        raise HTTPException(status_code=400, detail=f"{field} exceeds maximum length ({max_len})")
+    return value
+
+
+def scan_user_text(value: str, field: str = "input") -> str:
+    """Reject SSTI and injection probe strings in free-text fields."""
+    value = clamp_str(value, MAX_TEXT_FIELD, field)
+    if _SSTI.search(value):
+        raise HTTPException(status_code=400, detail="Invalid characters in request (template injection blocked)")
+    if _INJECTION.search(value):
+        raise HTTPException(status_code=400, detail="Invalid characters in request (injection blocked)")
+    return value
+
+
+def strip_for_regex(text: str, max_len: int = 500) -> str:
+    """ReDoS-safe prep: cap length before regex; strip without nested backtracking."""
+    if not text:
+        return ""
+    text = text[:max_len]
+    # Simple character removal instead of heavy regex on long strings
+    out = []
+    for ch in text:
+        if ch in "()[]":
+            continue
+        out.append(ch)
+    return "".join(out)
+
+
+def normalize_asin_safe(asin: str) -> str:
+    cleaned = (asin or "").upper().strip()[:16]
+    if not _ASIN.match(cleaned):
+        raise HTTPException(status_code=400, detail="Invalid ASIN — must be 10 alphanumeric characters")
+    return cleaned

app/security/middleware.py

@@ -1,67 +1,67 @@
-"""Security middleware: headers, body size, injection scan on JSON bodies."""
-import json
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
-
-from app.security.input_guard import MAX_TEXT_FIELD, _INJECTION, _SSTI
-
-MAX_BODY_BYTES = 512_000  # 512 KB
-
-
-class SecurityHeadersMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next) -> Response:
-        response = await call_next(request)
-        response.headers["X-Content-Type-Options"] = "nosniff"
-        response.headers["X-Frame-Options"] = "DENY"
-        response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
-        response.headers["Permissions-Policy"] = "geolocation=(), microphone=(), camera=()"
-        if request.url.path.startswith("/api/auth"):
-            response.headers["Cache-Control"] = "no-store"
-        return response
-
-
-class RequestGuardMiddleware(BaseHTTPMiddleware):
-    """Block oversized bodies and scan auth JSON for SSTI/injection probes."""
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        if request.method in ("POST", "PUT", "PATCH") and request.url.path.startswith("/api/auth"):
-            content_length = request.headers.get("content-length")
-            if content_length and int(content_length) > MAX_BODY_BYTES:
-                return JSONResponse(status_code=413, content={"detail": "Request body too large"})
-
-            ctype = (request.headers.get("content-type") or "").lower()
-            if "application/json" in ctype:
-                body = await request.body()
-                if len(body) > MAX_BODY_BYTES:
-                    return JSONResponse(status_code=413, content={"detail": "Request body too large"})
-                if body:
-                    try:
-                        data = json.loads(body)
-                        if _json_has_threats(data):
-                            return JSONResponse(status_code=400, content={"detail": "Invalid request content blocked"})
-                    except json.JSONDecodeError:
-                        return JSONResponse(status_code=400, content={"detail": "Invalid JSON"})
-
-                async def receive():
-                    return {"type": "http.request", "body": body, "more_body": False}
-
-                request = Request(request.scope, receive)
-
-        return await call_next(request)
-
-
-def _json_has_threats(obj, depth: int = 0) -> bool:
-    if depth > 12:
-        return True
-    if isinstance(obj, str):
-        if len(obj) > MAX_TEXT_FIELD:
-            return True
-        if _SSTI.search(obj) or _INJECTION.search(obj):
-            return True
-        return False
-    if isinstance(obj, dict):
-        return any(_json_has_threats(v, depth + 1) for v in obj.values())
-    if isinstance(obj, list):
-        return any(_json_has_threats(v, depth + 1) for v in obj[:200])
-    return False
+"""Security middleware: headers, body size, injection scan on JSON bodies."""
+import json
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+
+from app.security.input_guard import MAX_TEXT_FIELD, _INJECTION, _SSTI
+
+MAX_BODY_BYTES = 512_000  # 512 KB
+
+
+class SecurityHeadersMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next) -> Response:
+        response = await call_next(request)
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["X-Frame-Options"] = "DENY"
+        response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
+        response.headers["Permissions-Policy"] = "geolocation=(), microphone=(), camera=()"
+        if request.url.path.startswith("/api/auth"):
+            response.headers["Cache-Control"] = "no-store"
+        return response
+
+
+class RequestGuardMiddleware(BaseHTTPMiddleware):
+    """Block oversized bodies and scan auth JSON for SSTI/injection probes."""
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        if request.method in ("POST", "PUT", "PATCH") and request.url.path.startswith("/api/auth"):
+            content_length = request.headers.get("content-length")
+            if content_length and int(content_length) > MAX_BODY_BYTES:
+                return JSONResponse(status_code=413, content={"detail": "Request body too large"})
+
+            ctype = (request.headers.get("content-type") or "").lower()
+            if "application/json" in ctype:
+                body = await request.body()
+                if len(body) > MAX_BODY_BYTES:
+                    return JSONResponse(status_code=413, content={"detail": "Request body too large"})
+                if body:
+                    try:
+                        data = json.loads(body)
+                        if _json_has_threats(data):
+                            return JSONResponse(status_code=400, content={"detail": "Invalid request content blocked"})
+                    except json.JSONDecodeError:
+                        return JSONResponse(status_code=400, content={"detail": "Invalid JSON"})
+
+                async def receive():
+                    return {"type": "http.request", "body": body, "more_body": False}
+
+                request = Request(request.scope, receive)
+
+        return await call_next(request)
+
+
+def _json_has_threats(obj, depth: int = 0) -> bool:
+    if depth > 12:
+        return True
+    if isinstance(obj, str):
+        if len(obj) > MAX_TEXT_FIELD:
+            return True
+        if _SSTI.search(obj) or _INJECTION.search(obj):
+            return True
+        return False
+    if isinstance(obj, dict):
+        return any(_json_has_threats(v, depth + 1) for v in obj.values())
+    if isinstance(obj, list):
+        return any(_json_has_threats(v, depth + 1) for v in obj[:200])
+    return False

app/security/rate_limit.py

@@ -1,70 +1,70 @@
-"""Rate limiting for auth and expensive API routes."""
-import time
-from collections import defaultdict
-from threading import Lock
-from fastapi import HTTPException, Request
-
-_lock = Lock()
-_buckets: dict[str, list[float]] = defaultdict(list)
-
-AUTH_LIMIT = 10
-AUTH_WINDOW_SEC = 900
-
-AI_CHAT_LIMIT = 40
-AI_CHAT_WINDOW_SEC = 3600
-
-API_SCRAPE_LIMIT = 30
-API_SCRAPE_WINDOW_SEC = 3600
-
-
-def _client_ip(request: Request) -> str:
-    forwarded = request.headers.get("x-forwarded-for")
-    if forwarded:
-        return forwarded.split(",")[0].strip()[:64]
-    if request.client:
-        return request.client.host or "unknown"
-    return "unknown"
-
-
-def _client_ip_safe(request: Request) -> str:
-    try:
-        return _client_ip(request)
-    except Exception:
-        return "unknown"
-
-
-def _enforce(key: str, limit: int, window_sec: int, message: str) -> None:
-    now = time.time()
-    with _lock:
-        hits = [t for t in _buckets[key] if now - t < window_sec]
-        if len(hits) >= limit:
-            raise HTTPException(status_code=429, detail=message)
-        hits.append(now)
-        _buckets[key] = hits
-
-
-def enforce_auth_rate_limit(request: Request, action: str = "auth") -> None:
-    _enforce(
-        f"{action}:{_client_ip_safe(request)}",
-        AUTH_LIMIT,
-        AUTH_WINDOW_SEC,
-        "Too many attempts. Please wait and try again.",
-    )
-
-
-def enforce_ai_rate_limit(user_id: str) -> None:
-    _enforce(
-        f"ai:{user_id}",
-        AI_CHAT_LIMIT,
-        AI_CHAT_WINDOW_SEC,
-        "AI chat rate limit reached. Please wait before sending more messages.",
-    )
-
-
-def enforce_scrape_rate_limit(user_id: str, request: Request) -> None:
-    _enforce(
-        f"scrape:{user_id}",
-        API_SCRAPE_LIMIT,
-        API_SCRAPE_WINDOW_SEC,
-        "Product refresh limit reached. Please wait before refreshing again.",
-    )
+"""Rate limiting for auth and expensive API routes."""
+import time
+from collections import defaultdict
+from threading import Lock
+from fastapi import HTTPException, Request
+
+_lock = Lock()
+_buckets: dict[str, list[float]] = defaultdict(list)
+
+AUTH_LIMIT = 10
+AUTH_WINDOW_SEC = 900
+
+AI_CHAT_LIMIT = 40
+AI_CHAT_WINDOW_SEC = 3600
+
+API_SCRAPE_LIMIT = 30
+API_SCRAPE_WINDOW_SEC = 3600
+
+
+def _client_ip(request: Request) -> str:
+    forwarded = request.headers.get("x-forwarded-for")
+    if forwarded:
+        return forwarded.split(",")[0].strip()[:64]
+    if request.client:
+        return request.client.host or "unknown"
+    return "unknown"
+
+
+def _client_ip_safe(request: Request) -> str:
+    try:
+        return _client_ip(request)
+    except Exception:
+        return "unknown"
+
+
+def _enforce(key: str, limit: int, window_sec: int, message: str) -> None:
+    now = time.time()
+    with _lock:
+        hits = [t for t in _buckets[key] if now - t < window_sec]
+        if len(hits) >= limit:
+            raise HTTPException(status_code=429, detail=message)
+        hits.append(now)
+        _buckets[key] = hits
+
+
+def enforce_auth_rate_limit(request: Request, action: str = "auth") -> None:
+    _enforce(
+        f"{action}:{_client_ip_safe(request)}",
+        AUTH_LIMIT,
+        AUTH_WINDOW_SEC,
+        "Too many attempts. Please wait and try again.",
+    )
+
+
+def enforce_ai_rate_limit(user_id: str) -> None:
+    _enforce(
+        f"ai:{user_id}",
+        AI_CHAT_LIMIT,
+        AI_CHAT_WINDOW_SEC,
+        "AI chat rate limit reached. Please wait before sending more messages.",
+    )
+
+
+def enforce_scrape_rate_limit(user_id: str, request: Request) -> None:
+    _enforce(
+        f"scrape:{user_id}",
+        API_SCRAPE_LIMIT,
+        API_SCRAPE_WINDOW_SEC,
+        "Product refresh limit reached. Please wait before refreshing again.",
+    )

app/security/secrets.py

@@ -1,44 +1,44 @@
-"""Secret-key validation — prevent weak or leaked defaults in production."""
-from app.config import settings
-
-# Hard block — obvious placeholders only (app will not start)
-_BLOCKED_KEYS = {
-    "change-this",
-    "secret",
-    "your-secret-key",
-    "dev-secret",
-    "changeme",
-    "password",
-}
-
-# Warn only — previously leaked or weak but may still be in HF secrets until user rotates
-_WARN_KEYS = {
-    "rankora-super-secret-jwt-key-2026-shoaib",
-}
-
-
-def validate_production_secrets() -> None:
-    key = (settings.secret_key or "").strip()
-    if not key:
-        raise RuntimeError("SECRET_KEY is required — set it in Hugging Face Space secrets")
-    if len(key) < 24:
-        raise RuntimeError("SECRET_KEY must be at least 24 characters")
-    low = key.lower()
-    if low in _BLOCKED_KEYS or "change-this" in low:
-        raise RuntimeError("SECRET_KEY is a default placeholder — set a unique random secret in HF Space settings")
-    if key in _WARN_KEYS or low in {k.lower() for k in _WARN_KEYS}:
-        print(
-            "⚠️  SECURITY WARNING: SECRET_KEY matches a known weak/leaked value. "
-            "Rotate it in HF Space → Settings → Secrets (use: openssl rand -hex 32)"
-        )
-    if settings.debug and settings.secret_key == "change-this":
-        print("⚠️  WARNING: Using default SECRET_KEY in debug mode only")
-
-
-def redact(value: str | None) -> str:
-    """Redact secrets for logs/responses."""
-    if not value:
-        return ""
-    if len(value) <= 8:
-        return "***"
-    return value[:3] + "***" + value[-2:]
+"""Secret-key validation — prevent weak or leaked defaults in production."""
+from app.config import settings
+
+# Hard block — obvious placeholders only (app will not start)
+_BLOCKED_KEYS = {
+    "change-this",
+    "secret",
+    "your-secret-key",
+    "dev-secret",
+    "changeme",
+    "password",
+}
+
+# Warn only — previously leaked or weak but may still be in HF secrets until user rotates
+_WARN_KEYS = {
+    "rankora-super-secret-jwt-key-2026-shoaib",
+}
+
+
+def validate_production_secrets() -> None:
+    key = (settings.secret_key or "").strip()
+    if not key:
+        raise RuntimeError("SECRET_KEY is required — set it in Hugging Face Space secrets")
+    if len(key) < 24:
+        raise RuntimeError("SECRET_KEY must be at least 24 characters")
+    low = key.lower()
+    if low in _BLOCKED_KEYS or "change-this" in low:
+        raise RuntimeError("SECRET_KEY is a default placeholder — set a unique random secret in HF Space settings")
+    if key in _WARN_KEYS or low in {k.lower() for k in _WARN_KEYS}:
+        print(
+            "⚠️  SECURITY WARNING: SECRET_KEY matches a known weak/leaked value. "
+            "Rotate it in HF Space → Settings → Secrets (use: openssl rand -hex 32)"
+        )
+    if settings.debug and settings.secret_key == "change-this":
+        print("⚠️  WARNING: Using default SECRET_KEY in debug mode only")
+
+
+def redact(value: str | None) -> str:
+    """Redact secrets for logs/responses."""
+    if not value:
+        return ""
+    if len(value) <= 8:
+        return "***"
+    return value[:3] + "***" + value[-2:]

app/security/token_revocation.py

@@ -1,38 +1,38 @@
-"""JWT replay protection — jti denylist + per-user token version."""
-import time
-import uuid
-from threading import Lock
-
-_lock = Lock()
-_revoked_jti: dict[str, float] = {}  # jti -> expiry unix time
-_TTL_BUFFER_SEC = 86400 * 2
-
-
-def new_jti() -> str:
-    return str(uuid.uuid4())
-
-
-def revoke_jti(jti: str, exp_unix: float | None = None) -> None:
-    if not jti:
-        return
-    until = exp_unix or (time.time() + _TTL_BUFFER_SEC)
-    with _lock:
-        _revoked_jti[jti] = until
-        _purge_expired_locked()
-
-
-def is_jti_revoked(jti: str | None) -> bool:
-    if not jti:
-        return False
-    now = time.time()
-    with _lock:
-        _purge_expired_locked()
-        until = _revoked_jti.get(jti)
-        return until is not None and until > now
-
-
-def _purge_expired_locked() -> None:
-    now = time.time()
-    expired = [k for k, v in _revoked_jti.items() if v <= now]
-    for k in expired:
-        del _revoked_jti[k]
+"""JWT replay protection — jti denylist + per-user token version."""
+import time
+import uuid
+from threading import Lock
+
+_lock = Lock()
+_revoked_jti: dict[str, float] = {}  # jti -> expiry unix time
+_TTL_BUFFER_SEC = 86400 * 2
+
+
+def new_jti() -> str:
+    return str(uuid.uuid4())
+
+
+def revoke_jti(jti: str, exp_unix: float | None = None) -> None:
+    if not jti:
+        return
+    until = exp_unix or (time.time() + _TTL_BUFFER_SEC)
+    with _lock:
+        _revoked_jti[jti] = until
+        _purge_expired_locked()
+
+
+def is_jti_revoked(jti: str | None) -> bool:
+    if not jti:
+        return False
+    now = time.time()
+    with _lock:
+        _purge_expired_locked()
+        until = _revoked_jti.get(jti)
+        return until is not None and until > now
+
+
+def _purge_expired_locked() -> None:
+    now = time.time()
+    expired = [k for k, v in _revoked_jti.items() if v <= now]
+    for k in expired:
+        del _revoked_jti[k]

app/services/amazon/competitor_service.py

@@ -1,138 +1,138 @@
-import requests
-from bs4 import BeautifulSoup
-from typing import List, Dict, Optional
-from app.config import settings
-import re
-
-def scrape_category_bestsellers(category_url: str) -> List[Dict]:
-    """Scrape Amazon bestseller list for a category"""
-    scraper_url = "https://api.scraperapi.com"
-    params = {
-        "api_key": settings.scraper_api_key,
-        "url": category_url,
-        "country_code": "us",
-    }
-    
-    try:
-        response = requests.get(scraper_url, params=params, timeout=60)
-        if response.status_code != 200 or len(response.text) < 3000:
-            return []
-        
-        soup = BeautifulSoup(response.text, "html.parser")
-        competitors = []
-        
-        # Find product grid items
-        items = soup.find_all("div", {"class": re.compile(r"zg-grid-general-faceout|p13n-sc-uncoverable-faceout")})
-        
-        for item in items[:10]:
-            try:
-                # Title
-                title_elem = item.find("span", {"class": re.compile(r"a-size-base|zg-text-center-align")})
-                title = title_elem.get_text(strip=True) if title_elem else None
-                
-                # ASIN from link
-                link = item.find("a", href=True)
-                asin = None
-                if link:
-                    match = re.search(r"/dp/([A-Z0-9]{10})", link["href"])
-                    if match:
-                        asin = match.group(1)
-                
-                # Price
-                price = None
-                price_elem = item.find("span", {"class": re.compile(r"a-price|p13n-sc-price")})
-                if price_elem:
-                    try:
-                        price_text = price_elem.get_text(strip=True).replace("$", "").replace(",", "")
-                        price = float(price_text.split()[0])
-                    except:
-                        pass
-                
-                # Rating
-                rating = None
-                rating_elem = item.find("span", {"class": "a-icon-alt"})
-                if rating_elem:
-                    try:
-                        rating = float(rating_elem.get_text().split()[0])
-                    except:
-                        pass
-                
-                if asin and title:
-                    competitors.append({
-                        "asin": asin,
-                        "title": title[:100],
-                        "price": price,
-                        "rating": rating,
-                    })
-            except:
-                continue
-        
-        return competitors
-    except Exception as e:
-        print(f"Competitor scrape error: {e}")
-        return []
-
-
-def get_mock_competitors(asin: str, category: str) -> List[Dict]:
-    """Return mock competitors when scraping fails"""
-    category_products = {
-        "books": [
-            {"asin": "B08CMF2CQF", "title": "Clean Code", "price": 35.99, "rating": 4.7, "bsr": 1200, "review_count": 8500},
-            {"asin": "B07X9RQ7PL", "title": "The Pragmatic Programmer", "price": 39.99, "rating": 4.6, "bsr": 1800, "review_count": 5200},
-            {"asin": "B00B77ER5O", "title": "Code Complete", "price": 42.00, "rating": 4.5, "bsr": 2100, "review_count": 3800},
-            {"asin": "B01NAEKSTD", "title": "Design Patterns", "price": 44.99, "rating": 4.4, "bsr": 3500, "review_count": 2900},
-            {"asin": "B07FPFL5SG", "title": "Refactoring", "price": 38.00, "rating": 4.5, "bsr": 4200, "review_count": 2100},
-        ],
-        "electronics": [
-            {"asin": "B09B93ZDY4", "title": "Competitor Device A", "price": 49.99, "rating": 4.3, "bsr": 3000, "review_count": 12000},
-            {"asin": "B08F7N3T7X", "title": "Competitor Device B", "price": 39.99, "rating": 4.1, "bsr": 5500, "review_count": 8700},
-            {"asin": "B07YZB567G", "title": "Competitor Device C", "price": 59.99, "rating": 4.5, "bsr": 2200, "review_count": 15000},
-        ],
-        "default": [
-            {"asin": "B08X1Y2Z3A", "title": "Similar Product A", "price": 24.99, "rating": 4.2, "bsr": 8000, "review_count": 3200},
-            {"asin": "B09A2B3C4D", "title": "Similar Product B", "price": 29.99, "rating": 4.4, "bsr": 6500, "review_count": 4800},
-            {"asin": "B07E5F6G7H", "title": "Similar Product C", "price": 19.99, "rating": 4.0, "bsr": 12000, "review_count": 1900},
-            {"asin": "B08H9I0J1K", "title": "Similar Product D", "price": 34.99, "rating": 4.6, "bsr": 4200, "review_count": 7100},
-            {"asin": "B09L2M3N4O", "title": "Similar Product E", "price": 22.99, "rating": 3.9, "bsr": 18000, "review_count": 890},
-        ]
-    }
-    
-    cat_lower = (category or "").lower()
-    products = category_products.get("default")
-    for key in category_products:
-        if key in cat_lower:
-            products = category_products[key]
-            break
-    
-    # Add market share estimates
-    total_sales = sum(max(0, 100000 - p.get("bsr", 50000)) for p in products)
-    result = []
-    for p in products:
-        sales_estimate = max(0, 100000 - p.get("bsr", 50000))
-        market_share = round((sales_estimate / total_sales * 100) if total_sales > 0 else 0, 1)
-        result.append({**p, "market_share": market_share, "sales_estimate": sales_estimate // 1000})
-    
-    return result
-
-
-def get_competitors_for_product(asin: str, category: str, title: str = "") -> tuple:
-    """
-    Try live Amazon search scrape; fall back to category-based estimates.
-    Returns (competitors_list, data_source).
-    """
-    keyword = (category or title or "product").split()[0:3]
-    seed = " ".join(keyword) if keyword else category or "bestseller"
-
-    if settings.scraper_api_key:
-        search_url = f"https://www.amazon.com/s?k={seed.replace(' ', '+')}"
-        live = scrape_category_bestsellers(search_url)
-        live = [c for c in live if c.get("asin") != asin][:8]
-        if live:
-            total = sum(max(1, 100000 - (c.get("bsr") or 50000)) for c in live) or 1
-            for c in live:
-                est = max(1, 100000 - (c.get("bsr") or 50000))
-                c["market_share"] = round(est / total * 100, 1)
-                c["sales_estimate"] = est // 1000
-            return live, "live"
-
+import requests
+from bs4 import BeautifulSoup
+from typing import List, Dict, Optional
+from app.config import settings
+import re
+
+def scrape_category_bestsellers(category_url: str) -> List[Dict]:
+    """Scrape Amazon bestseller list for a category"""
+    scraper_url = "https://api.scraperapi.com"
+    params = {
+        "api_key": settings.scraper_api_key,
+        "url": category_url,
+        "country_code": "us",
+    }
+    
+    try:
+        response = requests.get(scraper_url, params=params, timeout=60)
+        if response.status_code != 200 or len(response.text) < 3000:
+            return []
+        
+        soup = BeautifulSoup(response.text, "html.parser")
+        competitors = []
+        
+        # Find product grid items
+        items = soup.find_all("div", {"class": re.compile(r"zg-grid-general-faceout|p13n-sc-uncoverable-faceout")})
+        
+        for item in items[:10]:
+            try:
+                # Title
+                title_elem = item.find("span", {"class": re.compile(r"a-size-base|zg-text-center-align")})
+                title = title_elem.get_text(strip=True) if title_elem else None
+                
+                # ASIN from link
+                link = item.find("a", href=True)
+                asin = None
+                if link:
+                    match = re.search(r"/dp/([A-Z0-9]{10})", link["href"])
+                    if match:
+                        asin = match.group(1)
+                
+                # Price
+                price = None
+                price_elem = item.find("span", {"class": re.compile(r"a-price|p13n-sc-price")})
+                if price_elem:
+                    try:
+                        price_text = price_elem.get_text(strip=True).replace("$", "").replace(",", "")
+                        price = float(price_text.split()[0])
+                    except:
+                        pass
+                
+                # Rating
+                rating = None
+                rating_elem = item.find("span", {"class": "a-icon-alt"})
+                if rating_elem:
+                    try:
+                        rating = float(rating_elem.get_text().split()[0])
+                    except:
+                        pass
+                
+                if asin and title:
+                    competitors.append({
+                        "asin": asin,
+                        "title": title[:100],
+                        "price": price,
+                        "rating": rating,
+                    })
+            except:
+                continue
+        
+        return competitors
+    except Exception as e:
+        print(f"Competitor scrape error: {e}")
+        return []
+
+
+def get_mock_competitors(asin: str, category: str) -> List[Dict]:
+    """Return mock competitors when scraping fails"""
+    category_products = {
+        "books": [
+            {"asin": "B08CMF2CQF", "title": "Clean Code", "price": 35.99, "rating": 4.7, "bsr": 1200, "review_count": 8500},
+            {"asin": "B07X9RQ7PL", "title": "The Pragmatic Programmer", "price": 39.99, "rating": 4.6, "bsr": 1800, "review_count": 5200},
+            {"asin": "B00B77ER5O", "title": "Code Complete", "price": 42.00, "rating": 4.5, "bsr": 2100, "review_count": 3800},
+            {"asin": "B01NAEKSTD", "title": "Design Patterns", "price": 44.99, "rating": 4.4, "bsr": 3500, "review_count": 2900},
+            {"asin": "B07FPFL5SG", "title": "Refactoring", "price": 38.00, "rating": 4.5, "bsr": 4200, "review_count": 2100},
+        ],
+        "electronics": [
+            {"asin": "B09B93ZDY4", "title": "Competitor Device A", "price": 49.99, "rating": 4.3, "bsr": 3000, "review_count": 12000},
+            {"asin": "B08F7N3T7X", "title": "Competitor Device B", "price": 39.99, "rating": 4.1, "bsr": 5500, "review_count": 8700},
+            {"asin": "B07YZB567G", "title": "Competitor Device C", "price": 59.99, "rating": 4.5, "bsr": 2200, "review_count": 15000},
+        ],
+        "default": [
+            {"asin": "B08X1Y2Z3A", "title": "Similar Product A", "price": 24.99, "rating": 4.2, "bsr": 8000, "review_count": 3200},
+            {"asin": "B09A2B3C4D", "title": "Similar Product B", "price": 29.99, "rating": 4.4, "bsr": 6500, "review_count": 4800},
+            {"asin": "B07E5F6G7H", "title": "Similar Product C", "price": 19.99, "rating": 4.0, "bsr": 12000, "review_count": 1900},
+            {"asin": "B08H9I0J1K", "title": "Similar Product D", "price": 34.99, "rating": 4.6, "bsr": 4200, "review_count": 7100},
+            {"asin": "B09L2M3N4O", "title": "Similar Product E", "price": 22.99, "rating": 3.9, "bsr": 18000, "review_count": 890},
+        ]
+    }
+    
+    cat_lower = (category or "").lower()
+    products = category_products.get("default")
+    for key in category_products:
+        if key in cat_lower:
+            products = category_products[key]
+            break
+    
+    # Add market share estimates
+    total_sales = sum(max(0, 100000 - p.get("bsr", 50000)) for p in products)
+    result = []
+    for p in products:
+        sales_estimate = max(0, 100000 - p.get("bsr", 50000))
+        market_share = round((sales_estimate / total_sales * 100) if total_sales > 0 else 0, 1)
+        result.append({**p, "market_share": market_share, "sales_estimate": sales_estimate // 1000})
+    
+    return result
+
+
+def get_competitors_for_product(asin: str, category: str, title: str = "") -> tuple:
+    """
+    Try live Amazon search scrape; fall back to category-based estimates.
+    Returns (competitors_list, data_source).
+    """
+    keyword = (category or title or "product").split()[0:3]
+    seed = " ".join(keyword) if keyword else category or "bestseller"
+
+    if settings.scraper_api_key:
+        search_url = f"https://www.amazon.com/s?k={seed.replace(' ', '+')}"
+        live = scrape_category_bestsellers(search_url)
+        live = [c for c in live if c.get("asin") != asin][:8]
+        if live:
+            total = sum(max(1, 100000 - (c.get("bsr") or 50000)) for c in live) or 1
+            for c in live:
+                est = max(1, 100000 - (c.get("bsr") or 50000))
+                c["market_share"] = round(est / total * 100, 1)
+                c["sales_estimate"] = est // 1000
+            return live, "live"
+
     return get_mock_competitors(asin, category), "estimated"

app/services/amazon/keyword_service.py

@@ -1,132 +1,132 @@
-import requests
-from typing import List, Dict
-import time
-
-def get_amazon_suggestions(keyword: str) -> List[str]:
-    """Get Amazon autocomplete suggestions"""
-    try:
-        url = "https://completion.amazon.com/api/2017/suggestions"
-        params = {
-            "word": keyword,
-            "marketplace": "US",
-            "session-id": "123-1234567-1234567",
-            "customer-id": "",
-            "request-id": "123456789",
-            "page-type": "Gateway",
-            "lop": "en_US",
-            "site-variant": "desktop",
-            "client-info": "amazon-search-ui",
-            "mid": "ATVPDKIKX0DER",
-            "alias": "aps",
-            "b2b": "0",
-            "fresh": "0",
-            "ks": "80",
-            "prefix": keyword,
-            "event": "onKeyPress",
-            "limit": "11",
-            "fb": "1",
-        }
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-        }
-        response = requests.get(url, params=params, headers=headers, timeout=10)
-        if response.status_code == 200:
-            data = response.json()
-            suggestions = []
-            for item in data.get("suggestions", []):
-                value = item.get("value", "")
-                if value and value != keyword:
-                    suggestions.append(value)
-            return suggestions[:10]
-    except Exception as e:
-        print(f"Suggestion error: {e}")
-    return []
-
-
-def estimate_search_volume(keyword: str) -> Dict:
-    """Estimate search volume based on keyword characteristics"""
-    word_count = len(keyword.split())
-    char_count = len(keyword)
-    
-    # Heuristic scoring
-    base_volume = 50000
-    
-    # Shorter keywords = higher volume
-    if word_count == 1:
-        volume = base_volume
-    elif word_count == 2:
-        volume = int(base_volume * 0.4)
-    elif word_count == 3:
-        volume = int(base_volume * 0.15)
-    else:
-        volume = int(base_volume * 0.05)
-    
-    # Competition estimate
-    if word_count <= 2:
-        competition = "high"
-        competition_score = 0.8
-    elif word_count == 3:
-        competition = "medium"
-        competition_score = 0.5
-    else:
-        competition = "low"
-        competition_score = 0.2
-    
-    is_long_tail = word_count >= 3
-    
-    return {
-        "keyword": keyword,
-        "search_volume_estimate": volume,
-        "competition": competition,
-        "competition_score": competition_score,
-        "is_long_tail": is_long_tail,
-        "word_count": word_count,
-        "opportunity_score": round((1 - competition_score) * (volume / base_volume) * 100, 1)
-    }
-
-
-def get_keywords_for_product(title: str, asin: str) -> List[Dict]:
-    """Generate keywords from product title + suggestions"""
-    if not title:
-        return []
-    
-    # Extract seed keywords from title
-    stop_words = {"the", "a", "an", "and", "or", "but", "in", "on", "at", "to", 
-                  "for", "of", "with", "by", "from", "edition", "version", "2nd",
-                  "new", "best", "top", "great", "good", "perfect"}
-    
-    words = title.lower().split()
-    seed_keywords = []
-    
-    # Single important words
-    for word in words:
-        clean = word.strip(".,!?()[]")
-        if len(clean) > 3 and clean not in stop_words:
-            seed_keywords.append(clean)
-    
-    # 2-word combinations
-    for i in range(len(words) - 1):
-        w1 = words[i].strip(".,!?()[]")
-        w2 = words[i+1].strip(".,!?()[]")
-        if w1 not in stop_words and w2 not in stop_words and len(w1) > 2 and len(w2) > 2:
-            seed_keywords.append(f"{w1} {w2}")
-    
-    # Get suggestions for top seeds
-    all_keywords = list(set(seed_keywords[:5]))
-    
-    for seed in seed_keywords[:3]:
-        suggestions = get_amazon_suggestions(seed)
-        all_keywords.extend(suggestions)
-        time.sleep(0.3)
-    
-    # Score all keywords
-    scored = []
-    seen = set()
-    for kw in all_keywords:
-        if kw not in seen and len(kw) > 2:
-            seen.add(kw)
-            scored.append(estimate_search_volume(kw))
-    
-    # Sort by opportunity score
-    scored.sort(key=lambda x: x["opportunity_score"], reverse=True)
+import requests
+from typing import List, Dict
+import time
+
+def get_amazon_suggestions(keyword: str) -> List[str]:
+    """Get Amazon autocomplete suggestions"""
+    try:
+        url = "https://completion.amazon.com/api/2017/suggestions"
+        params = {
+            "word": keyword,
+            "marketplace": "US",
+            "session-id": "123-1234567-1234567",
+            "customer-id": "",
+            "request-id": "123456789",
+            "page-type": "Gateway",
+            "lop": "en_US",
+            "site-variant": "desktop",
+            "client-info": "amazon-search-ui",
+            "mid": "ATVPDKIKX0DER",
+            "alias": "aps",
+            "b2b": "0",
+            "fresh": "0",
+            "ks": "80",
+            "prefix": keyword,
+            "event": "onKeyPress",
+            "limit": "11",
+            "fb": "1",
+        }
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+        }
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            suggestions = []
+            for item in data.get("suggestions", []):
+                value = item.get("value", "")
+                if value and value != keyword:
+                    suggestions.append(value)
+            return suggestions[:10]
+    except Exception as e:
+        print(f"Suggestion error: {e}")
+    return []
+
+
+def estimate_search_volume(keyword: str) -> Dict:
+    """Estimate search volume based on keyword characteristics"""
+    word_count = len(keyword.split())
+    char_count = len(keyword)
+    
+    # Heuristic scoring
+    base_volume = 50000
+    
+    # Shorter keywords = higher volume
+    if word_count == 1:
+        volume = base_volume
+    elif word_count == 2:
+        volume = int(base_volume * 0.4)
+    elif word_count == 3:
+        volume = int(base_volume * 0.15)
+    else:
+        volume = int(base_volume * 0.05)
+    
+    # Competition estimate
+    if word_count <= 2:
+        competition = "high"
+        competition_score = 0.8
+    elif word_count == 3:
+        competition = "medium"
+        competition_score = 0.5
+    else:
+        competition = "low"
+        competition_score = 0.2
+    
+    is_long_tail = word_count >= 3
+    
+    return {
+        "keyword": keyword,
+        "search_volume_estimate": volume,
+        "competition": competition,
+        "competition_score": competition_score,
+        "is_long_tail": is_long_tail,
+        "word_count": word_count,
+        "opportunity_score": round((1 - competition_score) * (volume / base_volume) * 100, 1)
+    }
+
+
+def get_keywords_for_product(title: str, asin: str) -> List[Dict]:
+    """Generate keywords from product title + suggestions"""
+    if not title:
+        return []
+    
+    # Extract seed keywords from title
+    stop_words = {"the", "a", "an", "and", "or", "but", "in", "on", "at", "to", 
+                  "for", "of", "with", "by", "from", "edition", "version", "2nd",
+                  "new", "best", "top", "great", "good", "perfect"}
+    
+    words = title.lower().split()
+    seed_keywords = []
+    
+    # Single important words
+    for word in words:
+        clean = word.strip(".,!?()[]")
+        if len(clean) > 3 and clean not in stop_words:
+            seed_keywords.append(clean)
+    
+    # 2-word combinations
+    for i in range(len(words) - 1):
+        w1 = words[i].strip(".,!?()[]")
+        w2 = words[i+1].strip(".,!?()[]")
+        if w1 not in stop_words and w2 not in stop_words and len(w1) > 2 and len(w2) > 2:
+            seed_keywords.append(f"{w1} {w2}")
+    
+    # Get suggestions for top seeds
+    all_keywords = list(set(seed_keywords[:5]))
+    
+    for seed in seed_keywords[:3]:
+        suggestions = get_amazon_suggestions(seed)
+        all_keywords.extend(suggestions)
+        time.sleep(0.3)
+    
+    # Score all keywords
+    scored = []
+    seen = set()
+    for kw in all_keywords:
+        if kw not in seen and len(kw) > 2:
+            seen.add(kw)
+            scored.append(estimate_search_volume(kw))
+    
+    # Sort by opportunity score
+    scored.sort(key=lambda x: x["opportunity_score"], reverse=True)
     return scored[:20]

app/services/amazon/offers_scraper.py

@@ -1,158 +1,204 @@
-"""Scrape live Amazon offer listing / AOD data for real seller competition."""
-from __future__ import annotations
-
-import re
-from typing import Dict, List, Optional, Tuple
-
-import requests
-from bs4 import BeautifulSoup
-
-from app.services.amazon.scraper_utils import get_headers, normalize_price, parse_int, parse_number
-
-
-def _parse_offer_row(offer_el) -> Optional[dict]:
-    """Parse a single offer block from AOD or offer-listing HTML."""
-    text = offer_el.get_text(" ", strip=True)
-    if not text or len(text) < 3:
-        return None
-
-    name = None
-    for sel in (
-        offer_el.select_one(".a-size-small.a-color-base"),
-        offer_el.select_one("#aod-offer-soldBy a"),
-        offer_el.select_one(".olpSellerName"),
-        offer_el.select_one("h3.olpSellerName"),
-        offer_el.find("a", href=re.compile(r"seller=")),
-    ):
-        if sel:
-            name = sel.get_text(strip=True)
-            if name and len(name) > 1:
-                break
-
-    if not name:
-        sold_match = re.search(r"(?:Sold by|from)\s+([^·|]+)", text, re.I)
-        if sold_match:
-            name = sold_match.group(1).strip()[:80]
-
-    price = None
-    for price_el in offer_el.select(".a-price .a-offscreen, .a-color-price, .olpOfferPrice"):
-        price = parse_number(price_el.get_text())
-        if price:
-            break
-    if price is None:
-        pm = re.search(r"\$\s*([\d,]+\.?\d*)", text)
-        if pm:
-            price = parse_number(pm.group(1))
-
-    is_fba = bool(
-        offer_el.find(string=re.compile(r"Fulfilled by Amazon|FBA", re.I))
-        or offer_el.select_one(".a-icon-prime")
-        or "Prime" in text and "Fulfilled" in text
-    )
-    is_fbm = bool(offer_el.find(string=re.compile(r"Ships from.*Sold by", re.I))) and not is_fba
-
-    if not name:
-        return None
-
-    return {
-        "name": name[:80],
-        "price": normalize_price(price) if price else None,
-        "is_fba": True if is_fba else (False if is_fbm else None),
-        "is_prime": bool(offer_el.select_one(".a-icon-prime")),
-        "rating": None,
-    }
-
-
-def scrape_offers(asin: str, timeout: int = 25) -> Tuple[List[dict], int, int, int]:
-    """
-    Fetch real competing offers for an ASIN.
-    Returns: (offers, seller_count, fba_count, fbm_count)
-    """
-    asin = asin.upper().strip()
-    offers: List[dict] = []
-    seen_names: set = set()
-
-    urls = [
-        f"https://www.amazon.com/gp/aod/ajax/ref=auto_load_aod?asin={asin}",
-        f"https://www.amazon.com/gp/product/ajax/aodAjaxMain/ref=auto_load_aod?asin={asin}",
-        f"https://www.amazon.com/gp/offer-listing/{asin}/ref=olp_tab_all",
-    ]
-
-    for url in urls:
-        try:
-            resp = requests.get(url, headers=get_headers(), timeout=timeout)
-            if resp.status_code != 200 or len(resp.text) < 200:
-                continue
-            soup = BeautifulSoup(resp.text, "html.parser")
-
-            rows = (
-                soup.select("#aod-offer-list #aod-offer")
-                or soup.select("#aod-offer")
-                or soup.select(".a-section.a-spacing-none.a-padding-base.olpOffer")
-                or soup.select("#olpOfferList .a-row")
-            )
-
-            for row in rows[:20]:
-                offer = _parse_offer_row(row)
-                if not offer:
-                    continue
-                key = offer["name"].lower()
-                if key in seen_names:
-                    continue
-                seen_names.add(key)
-                offers.append(offer)
-
-            if offers:
-                break
-        except Exception as e:
-            print(f"[offers_scraper] {url}: {e}")
-            continue
-
-    fba_count = sum(1 for o in offers if o.get("is_fba") is True)
-    fbm_count = sum(1 for o in offers if o.get("is_fba") is False)
-    unknown = sum(1 for o in offers if o.get("is_fba") is None)
-    seller_count = max(len(offers), 1)
-
-    return offers, seller_count, fba_count, fbm_count
-
-
-def enrich_product_offers(data: dict) -> dict:
-    """Attach scraped offers to product payload; never synthesize fake sellers."""
-    asin = data.get("asin")
-    if not asin:
-        return data
-
-    offers, count, fba, fbm = scrape_offers(asin)
-    if offers:
-        data["other_sellers"] = offers
-        data["seller_count"] = max(data.get("seller_count") or 1, count)
-        data["fba_seller_count"] = fba if fba > 0 else None
-        data["fbm_seller_count"] = fbm if fbm > 0 else None
-        data["offers_source"] = "live_aod"
-    else:
-        data["other_sellers"] = data.get("other_sellers") or []
-        data["offers_source"] = "product_page_only"
-    return data
-
-
-def extract_package_weight(soup: BeautifulSoup) -> Optional[float]:
-    """Extract item/package weight in pounds from product detail bullets."""
-    patterns = [
-        r"([\d.]+)\s*pounds",
-        r"([\d.]+)\s*lbs",
-        r"([\d.]+)\s*lb\b",
-        r"([\d.]+)\s*ounces",
-        r"([\d.]+)\s*oz\b",
-    ]
-    for block in soup.select("#detailBullets_feature_div li, #productDetails_detailBullets_sections1 tr, .prodDetSectionEntry"):
-        text = block.get_text(" ", strip=True).lower()
-        if "weight" not in text and "shipping weight" not in text and "item weight" not in text:
-            continue
-        for pat in patterns:
-            m = re.search(pat, text)
-            if m:
-                val = float(m.group(1))
-                if "ounce" in text or " oz" in text:
-                    return round(val / 16, 3)
-                return round(val, 3)
-    return None
+"""Scrape live Amazon offer listing / AOD data for real seller competition."""
+from __future__ import annotations
+
+import re
+from typing import Dict, List, Optional, Tuple
+
+import requests
+from bs4 import BeautifulSoup
+
+from app.config import settings
+from app.services.amazon.scraper_utils import get_headers, normalize_price, parse_number
+
+
+def _fetch_offers_html(url: str, timeout: int = 30) -> Optional[str]:
+    """Fetch offer-listing HTML — ScraperAPI on cloud, direct fetch as fallback."""
+    if settings.scraper_api_key:
+        try:
+            resp = requests.get(
+                "https://api.scraperapi.com",
+                params={
+                    "api_key": settings.scraper_api_key,
+                    "url": url,
+                    "country_code": "us",
+                },
+                timeout=timeout,
+            )
+            if resp.status_code == 200 and len(resp.text) > 200:
+                return resp.text
+            print(f"[offers_scraper] ScraperAPI HTTP {resp.status_code}")
+        except Exception as e:
+            print(f"[offers_scraper] ScraperAPI error: {e}")
+
+    try:
+        resp = requests.get(url, headers=get_headers(), timeout=timeout)
+        if resp.status_code == 200 and len(resp.text) > 200:
+            return resp.text
+    except Exception as e:
+        print(f"[offers_scraper] Direct fetch error: {e}")
+    return None
+
+
+def _parse_seller_rating(text: str) -> Optional[str]:
+    m = re.search(r"(\d{1,3})%\s*positive", text, re.I)
+    if m:
+        return f"{m.group(1)}%"
+    m = re.search(r"(\d{1,3})\s*%\s*ratings?", text, re.I)
+    if m:
+        return f"{m.group(1)}%"
+    return None
+
+
+def _parse_offer_row(offer_el) -> Optional[dict]:
+    """Parse a single offer block from AOD or offer-listing HTML."""
+    text = offer_el.get_text(" ", strip=True)
+    if not text or len(text) < 3:
+        return None
+
+    name = None
+    for sel in (
+        offer_el.select_one("#aod-offer-soldBy a"),
+        offer_el.select_one(".a-size-small.a-color-base"),
+        offer_el.select_one(".olpSellerName"),
+        offer_el.select_one("h3.olpSellerName"),
+        offer_el.find("a", href=re.compile(r"seller=")),
+    ):
+        if sel:
+            name = sel.get_text(strip=True)
+            if name and len(name) > 1 and name.lower() not in ("amazon.com", "new"):
+                break
+
+    if not name:
+        sold_match = re.search(r"(?:Sold by|from)\s+([^·|]+)", text, re.I)
+        if sold_match:
+            name = sold_match.group(1).strip()[:80]
+
+    price = None
+    for price_el in offer_el.select(
+        ".a-price .a-offscreen, .a-color-price, .olpOfferPrice, .a-price-whole"
+    ):
+        price = parse_number(price_el.get_text())
+        if price:
+            break
+    if price is None:
+        pm = re.search(r"\$\s*([\d,]+\.?\d*)", text)
+        if pm:
+            price = parse_number(pm.group(1))
+
+    is_fba = bool(
+        offer_el.find(string=re.compile(r"Fulfilled by Amazon|FBA", re.I))
+        or offer_el.select_one(".a-icon-prime")
+        or ("Prime" in text and "Fulfilled" in text)
+    )
+    is_fbm = bool(offer_el.find(string=re.compile(r"Ships from.*Sold by", re.I))) and not is_fba
+
+    if not name:
+        return None
+
+    return {
+        "name": name[:80],
+        "price": normalize_price(price) if price else None,
+        "is_fba": True if is_fba else (False if is_fbm else None),
+        "is_prime": bool(offer_el.select_one(".a-icon-prime")),
+        "rating": _parse_seller_rating(text),
+    }
+
+
+def scrape_offers(asin: str, timeout: int = 30) -> Tuple[List[dict], int, int, int]:
+    """
+    Fetch real competing offers for an ASIN.
+    Returns: (offers, seller_count, fba_count, fbm_count)
+    """
+    asin = asin.upper().strip()
+    offers: List[dict] = []
+    seen_names: set = set()
+
+    urls = [
+        f"https://www.amazon.com/gp/aod/ajax/ref=auto_load_aod?asin={asin}",
+        f"https://www.amazon.com/gp/product/ajax/aodAjaxMain/ref=auto_load_aod?asin={asin}",
+        f"https://www.amazon.com/gp/offer-listing/{asin}/ref=olp_tab_all",
+    ]
+
+    for url in urls:
+        html = _fetch_offers_html(url, timeout=timeout)
+        if not html:
+            continue
+        try:
+            soup = BeautifulSoup(html, "html.parser")
+
+            rows = (
+                soup.select("#aod-offer-list #aod-offer")
+                or soup.select("#aod-offer")
+                or soup.select(".a-section.a-spacing-none.a-padding-base.olpOffer")
+                or soup.select("#olpOfferList .a-row")
+                or soup.select("[data-aod-offer]")
+            )
+
+            for row in rows[:25]:
+                offer = _parse_offer_row(row)
+                if not offer:
+                    continue
+                key = offer["name"].lower()
+                if key in seen_names:
+                    continue
+                seen_names.add(key)
+                offers.append(offer)
+
+            if offers:
+                break
+        except Exception as e:
+            print(f"[offers_scraper] parse {url}: {e}")
+            continue
+
+    fba_count = sum(1 for o in offers if o.get("is_fba") is True)
+    fbm_count = sum(1 for o in offers if o.get("is_fba") is False)
+    seller_count = max(len(offers), 1)
+
+    return offers, seller_count, fba_count, fbm_count
+
+
+def enrich_product_offers(data: dict) -> dict:
+    """Attach scraped offers to product payload; never synthesize fake sellers."""
+    asin = data.get("asin")
+    if not asin:
+        return data
+
+    offers, count, fba, fbm = scrape_offers(asin)
+    winner = (data.get("buy_box_winner") or "").strip().lower()
+
+    if offers:
+        # Drop duplicate of buy box winner from the "other" list
+        filtered = [o for o in offers if o.get("name", "").strip().lower() != winner]
+        data["other_sellers"] = filtered
+        data["seller_count"] = max(data.get("seller_count") or 1, len(filtered) + (1 if winner else 0), count)
+        data["fba_seller_count"] = fba if fba > 0 else None
+        data["fbm_seller_count"] = fbm if fbm > 0 else None
+        data["offers_source"] = "live_aod"
+        print(f"[offers_scraper] ✅ {asin}: {len(filtered)} competing offers (+ buy box winner)")
+    else:
+        data["other_sellers"] = data.get("other_sellers") or []
+        data["offers_source"] = "product_page_only"
+    return data
+
+
+def extract_package_weight(soup: BeautifulSoup) -> Optional[float]:
+    """Extract item/package weight in pounds from product detail bullets."""
+    patterns = [
+        r"([\d.]+)\s*pounds",
+        r"([\d.]+)\s*lbs",
+        r"([\d.]+)\s*lb\b",
+        r"([\d.]+)\s*ounces",
+        r"([\d.]+)\s*oz\b",
+    ]
+    for block in soup.select("#detailBullets_feature_div li, #productDetails_detailBullets_sections1 tr, .prodDetSectionEntry"):
+        text = block.get_text(" ", strip=True).lower()
+        if "weight" not in text and "shipping weight" not in text and "item weight" not in text:
+            continue
+        for pat in patterns:
+            m = re.search(pat, text)
+            if m:
+                val = float(m.group(1))
+                if "ounce" in text or " oz" in text:
+                    return round(val / 16, 3)
+                return round(val, 3)
+    return None

app/services/amazon/product_scraper.py

@@ -1,417 +1,417 @@
-import random
-import re
-import time
-import requests
-from bs4 import BeautifulSoup
-from typing import Optional
-
-from app.config import settings
-from app.services.amazon.offers_scraper import enrich_product_offers, extract_package_weight
-from app.services.amazon.scraper_utils import (
-    get_headers as _get_headers,
-    normalize_price as _normalize_price,
-    parse_int as _parse_int,
-    parse_number as _parse_number,
-)
-
-
-def _extract_upc(soup: BeautifulSoup) -> Optional[str]:
-    """Extract UPC/EAN/GTIN from Amazon product detail sections."""
-    for row in soup.find_all("tr"):
-        th = row.find("th")
-        td = row.find("td")
-        if not th or not td:
-            continue
-        label = th.get_text(strip=True).lower()
-        if any(k in label for k in ("upc", "ean", "gtin")):
-            digits = re.sub(r"\D", "", td.get_text(strip=True))
-            if len(digits) >= 8:
-                return digits[:14]
-
-    for block in soup.select("#detailBullets_feature_div li, #productDetails_detailBullets_sections1 tr"):
-        text = block.get_text(" ", strip=True)
-        lower = text.lower()
-        if "upc" in lower or "ean" in lower or "gtin" in lower:
-            match = re.search(r"(\d{8,14})", text)
-            if match:
-                return match.group(1)
-
-    for script in soup.find_all("script", type="application/ld+json"):
-        raw = script.string or script.get_text()
-        if not raw or "gtin" not in raw.lower():
-            continue
-        match = re.search(r'"gtin(?:12|13|14)?"\s*:\s*"(\d{8,14})"', raw, re.I)
-        if match:
-            return match.group(1)
-    return None
-
-def get_mock_product(asin: str) -> dict:
-    data = {
-        "asin": asin,
-        "title": f"Amazon Product {asin}",
-        "brand": "Amazon Brand",
-        "category": "Electronics",
-        "price": 29.99,
-        "rating": 4.3,
-        "review_count": 1250,
-        "bsr": 5000,
-        "image_url": f"https://via.placeholder.com/300x300?text={asin}",
-        "amazon_url": f"https://www.amazon.com/dp/{asin}",
-        "in_stock": True,
-        "is_prime": True,
-        "buy_box_winner": "Amazon.com",
-        "buy_box_price": 29.99,
-        "buy_box_is_fba": True,
-        "buy_box_is_prime": True,
-        "seller_count": 3,
-        "fba_seller_count": 3,
-        "is_amazon_sold": True,
-        "has_buy_box": True,
-        "upc": "012345678905",
-        "other_sellers": [
-            {"name": "Seller A", "price": 31.99, "is_fba": True, "rating": "97%"},
-            {"name": "Seller B", "price": 32.50, "is_fba": False, "rating": "94%"},
-        ],
-        "data_source": "mock",
-    }
-    return data
-
-
-def _mock_or_none(asin: str) -> Optional[dict]:
-    if settings.allow_mock_data:
-        return get_mock_product(asin)
-    return None
-
-
-def _fetch_html(url: str, timeout: int = 60) -> Optional[str]:
-    """Fetch Amazon HTML — ScraperAPI on cloud servers, direct fetch as fallback."""
-    if settings.scraper_api_key:
-        try:
-            resp = requests.get(
-                "https://api.scraperapi.com",
-                params={
-                    "api_key": settings.scraper_api_key,
-                    "url": url,
-                    "country_code": "us",
-                },
-                timeout=timeout,
-            )
-            if resp.status_code == 200 and len(resp.text) > 500:
-                return resp.text
-            print(f"[scraper] ScraperAPI HTTP {resp.status_code} for {url[:70]}")
-        except Exception as e:
-            print(f"[scraper] ScraperAPI error: {e}")
-
-    try:
-        time.sleep(random.uniform(1.0, 2.5))
-        session = requests.Session()
-        try:
-            session.get("https://www.amazon.com", headers=_get_headers(), timeout=8)
-            time.sleep(random.uniform(0.5, 1.0))
-        except Exception:
-            pass
-        resp = session.get(url, headers=_get_headers(), timeout=12)
-        if resp.status_code == 200:
-            return resp.text
-    except Exception as e:
-        print(f"[scraper] Direct fetch error: {e}")
-    return None
-
-
-def scrape_amazon_product(asin: str) -> Optional[dict]:
-    url = f"https://www.amazon.com/dp/{asin}"
-    for attempt in range(2):
-        try:
-            html = _fetch_html(url)
-            if not html:
-                time.sleep(2)
-                continue
-
-            soup = BeautifulSoup(html, "html.parser")
-            page_text = soup.get_text().lower()
-
-            if "enter the characters you see below" in page_text or "sorry, we just need to make sure" in page_text:
-                return _mock_or_none(asin)
-
-            # ── Title ─────────────────────────────────────────────────────────
-            title = None
-            title_el = (
-                soup.find("span", id="productTitle") or
-                soup.find("h1", id="title") or
-                soup.find("span", {"class": "product-title-word-break"})
-            )
-            if title_el:
-                title = title_el.get_text(strip=True)
-            if not title:
-                return _mock_or_none(asin)
-
-            # ── Price ─────────────────────────────────────────────────────────
-            price = None
-            for tag, attrs in [
-                ("span", {"class": "a-price-whole"}),
-                ("span", {"id": "priceblock_ourprice"}),
-                ("span", {"id": "priceblock_dealprice"}),
-                ("span", {"class": "a-offscreen"}),
-            ]:
-                el = soup.find(tag, attrs)
-                if el:
-                    raw = _parse_number(el.get_text())
-                    if raw and raw > 0:
-                        price = raw
-                        break
-            price = _normalize_price(price)
-
-            # ── Rating ────────────────────────────────────────────────────────
-            rating = None
-            rating_el = (
-                soup.find("span", {"data-hook": "rating-out-of-text"}) or
-                soup.find("span", {"class": "a-icon-alt"}) or
-                soup.find("i", {"data-hook": "average-star-rating"})
-            )
-            if rating_el:
-                match = re.search(r"(\d+\.?\d*)\s*out of", rating_el.get_text())
-                if match:
-                    rating = float(match.group(1))
-
-            # ── Reviews ───────────────────────────────────────────────────────
-            review_count = None
-            review_el = (
-                soup.find("span", {"id": "acrCustomerReviewText"}) or
-                soup.find("span", {"data-hook": "total-review-count"})
-            )
-            if review_el:
-                review_count = _parse_int(review_el.get_text())
-
-            # ── BSR ───────────────────────────────────────────────────────────
-            bsr = None
-            bsr_section = soup.find("th", string=re.compile(r"Best Sellers Rank", re.I))
-            if not bsr_section:
-                bsr_section = soup.find("span", string=re.compile(r"Best Sellers Rank", re.I))
-            if bsr_section:
-                bsr_td = bsr_section.find_next("td") or bsr_section.find_next("span")
-                if bsr_td:
-                    match = re.search(r"#([\d,]+)", bsr_td.get_text())
-                    if match:
-                        bsr = _parse_int(match.group(1))
-            if not bsr:
-                for row in soup.find_all("tr"):
-                    th = row.find("th")
-                    td = row.find("td")
-                    if th and td and "best sellers rank" in th.get_text().lower():
-                        match = re.search(r"#([\d,]+)", td.get_text())
-                        if match:
-                            bsr = _parse_int(match.group(1))
-                            break
-
-            # ── Brand ─────────────────────────────────────────────────────────
-            brand = None
-            brand_el = soup.find("a", {"id": "bylineInfo"}) or soup.find("span", {"class": "author"})
-            if brand_el:
-                brand = re.sub(r"^(Visit the |Brand: )", "", brand_el.get_text(strip=True)).strip()
-                brand = re.sub(r"\s+Store$", "", brand, flags=re.I).strip()
-
-            # ── UPC ───────────────────────────────────────────────────────────
-            upc = _extract_upc(soup)
-
-            # ── Category ──────────────────────────────────────────────────────
-            category = None
-            breadcrumb = soup.find("div", {"id": "wayfinding-breadcrumbs_feature_div"})
-            if breadcrumb:
-                crumbs = breadcrumb.find_all("a")
-                if crumbs:
-                    category = crumbs[0].get_text(strip=True)
-
-            # ── Image ─────────────────────────────────────────────────────────
-            image_url = None
-            img_el = soup.find("img", {"id": "landingImage"}) or soup.find("img", {"id": "imgBlkFront"})
-            if img_el:
-                image_url = img_el.get("src") or img_el.get("data-old-hires")
-
-            # ── In Stock ──────────────────────────────────────────────────────
-            in_stock = True
-            availability_el = soup.find("div", {"id": "availability"})
-            if availability_el:
-                avail_text = availability_el.get_text(strip=True).lower()
-                in_stock = "in stock" in avail_text or "available" in avail_text
-
-            # ── Is Prime ──────────────────────────────────────────────────────
-            is_prime = soup.find("i", {"class": "a-icon-prime"}) is not None
-
-            # ════════════════════════════════════════════════════════════════
-            # BUY BOX DATA
-            # ════════════════════════════════════════════════════════════════
-
-            buy_box_winner = None
-            buy_box_price = price
-            buy_box_is_fba = False
-            buy_box_is_prime = is_prime
-            is_amazon_sold = False
-            seller_count = 1
-            fba_seller_count = 0
-            other_sellers = []
-            has_buy_box = True
-
-            # Who owns the buy box
-            merchant_el = (
-                soup.find("div", {"id": "merchant-info"}) or
-                soup.find("a", {"id": "sellerProfileTriggerId"}) or
-                soup.find("div", {"id": "tabular-buybox-truncate-0"})
-            )
-            if merchant_el:
-                merchant_text = merchant_el.get_text(strip=True)
-                if "amazon" in merchant_text.lower():
-                    buy_box_winner = "Amazon.com"
-                    is_amazon_sold = True
-                else:
-                    buy_box_winner = merchant_text[:50]
-
-            # Sold by Amazon check
-            sold_by_el = soup.find(string=re.compile(r"Sold by Amazon", re.I))
-            if sold_by_el:
-                buy_box_winner = "Amazon.com"
-                is_amazon_sold = True
-
-            # Ships from / sold by block
-            ships_block = soup.find("div", {"id": "tabular-buybox"})
-            if ships_block:
-                text = ships_block.get_text()
-                if "amazon" in text.lower():
-                    is_amazon_sold = True
-                    buy_box_winner = buy_box_winner or "Amazon.com"
-
-            # FBA check
-            fba_el = soup.find(string=re.compile(r"Fulfilled by Amazon", re.I))
-            if fba_el:
-                buy_box_is_fba = True
-
-            # FBM check — overrides if explicitly merchant fulfilled
-            fbm_el = soup.find(string=re.compile(r"Fulfillment by Merchant|Ships from.*sold by", re.I))
-            if fbm_el and not fba_el:
-                buy_box_is_fba = False
-
-            # Number of other sellers
-            sellers_el = soup.find("a", {"id": "olp-sl-new"}) or soup.find("span", string=re.compile(r"new from", re.I))
-            if sellers_el:
-                match = re.search(r"(\d+)", sellers_el.get_text())
-                if match:
-                    seller_count = int(match.group(1))
-
-            # Offer listing page — get other sellers
-            offer_el = soup.find("a", href=re.compile(r"/gp/offer-listing/"))
-            if offer_el:
-                offer_text = offer_el.get_text(strip=True)
-                match = re.search(r"(\d+)", offer_text)
-                if match:
-                    seller_count = max(seller_count, int(match.group(1)))
-
-            # Buy box price
-            buybox_price_el = (
-                soup.find("span", {"id": "price_inside_buybox"}) or
-                soup.find("span", {"id": "priceblock_ourprice"})
-            )
-            if buybox_price_el:
-                bb_price = _parse_number(buybox_price_el.get_text())
-                if bb_price:
-                    buy_box_price = _normalize_price(bb_price)
-
-            # Buy box availability
-            no_buybox_signals = (
-                soup.find("div", {"id": "outOfStock"})
-                or soup.find("span", {"id": "buybox-see-all-buying-choices"})
-                or soup.find(string=re.compile(r"no featured offers|currently unavailable", re.I))
-            )
-            add_to_cart = (
-                soup.find("input", {"id": "add-to-cart-button"})
-                or soup.find("span", {"id": "submit.add-to-cart"})
-                or soup.find("input", {"id": "buy-now-button"})
-            )
-            if no_buybox_signals and not add_to_cart:
-                has_buy_box = False
-            if not buy_box_price and not add_to_cart:
-                has_buy_box = False
-            if not in_stock:
-                has_buy_box = False
-
-            # Estimate FBA vs FBM seller split only when offers scrape did not run
-            if not other_sellers:
-                if buy_box_is_fba and has_buy_box:
-                    fba_seller_count = max(1, seller_count) if seller_count > 0 else 1
-                    fbm_seller_count = max(0, seller_count - fba_seller_count)
-                elif not buy_box_is_fba and has_buy_box:
-                    fbm_seller_count = max(1, seller_count) if seller_count > 0 else 1
-                    fba_seller_count = max(0, seller_count - fbm_seller_count)
-
-            package_weight_lbs = extract_package_weight(soup)
-
-            print(f"[scraper] ✅ {asin}: price=${price}, bsr={bsr}, rating={rating}, reviews={review_count}, buy_box={buy_box_winner}, sellers={seller_count}")
-
-            payload = {
-                "asin": asin,
-                "title": title,
-                "brand": brand or "Unknown",
-                "upc": upc,
-                "category": category or "General",
-                "image_url": image_url or "",
-                "amazon_url": url,
-                "price": price,
-                "bsr": bsr,
-                "rating": rating,
-                "review_count": review_count,
-                "in_stock": in_stock,
-                "is_prime": is_prime,
-                # Buy Box data
-                "buy_box_winner": buy_box_winner,
-                "buy_box_price": buy_box_price,
-                "buy_box_is_fba": buy_box_is_fba,
-                "buy_box_is_prime": buy_box_is_prime,
-                "seller_count": seller_count,
-                "fba_seller_count": fba_seller_count,
-                "fbm_seller_count": fbm_seller_count,
-                "has_buy_box": has_buy_box,
-                "is_amazon_sold": is_amazon_sold,
-                "other_sellers": other_sellers,
-                "package_weight_lbs": package_weight_lbs,
-                "data_source": "live",
-            }
-
-            if not buy_box_winner and has_buy_box:
-                buy_box_winner = "3rd Party Seller" if not is_amazon_sold else "Amazon.com"
-                payload["buy_box_winner"] = buy_box_winner
-            elif not has_buy_box:
-                payload["buy_box_winner"] = None
-                payload["buy_box_price"] = None
-
-            return enrich_product_offers(payload)
-
-        except requests.exceptions.Timeout:
-            time.sleep(2)
-        except requests.exceptions.RequestException:
-            time.sleep(2)
-        except Exception as e:
-            print(f"[scraper] Unexpected error: {e}")
-            return _mock_or_none(asin)
-
-    return _mock_or_none(asin)
-
-
-def search_asin_by_keyword(keyword: str) -> Optional[str]:
-    """Find the first ASIN from Amazon search results for a keyword."""
-    if not keyword or not keyword.strip():
-        return None
-    q = requests.utils.quote(keyword.strip())
-    url = f"https://www.amazon.com/s?k={q}"
-    try:
-        html = _fetch_html(url, timeout=45)
-        if not html:
-            return None
-        soup = BeautifulSoup(html, "html.parser")
-        for link in soup.find_all("a", href=True):
-            match = re.search(r"/dp/([A-Z0-9]{10})", link["href"])
-            if match:
-                return match.group(1)
-            match = re.search(r"/gp/product/([A-Z0-9]{10})", link["href"])
-            if match:
-                return match.group(1)
-    except Exception as e:
-        print(f"[scraper] Keyword search error: {e}")
+import random
+import re
+import time
+import requests
+from bs4 import BeautifulSoup
+from typing import Optional
+
+from app.config import settings
+from app.services.amazon.offers_scraper import enrich_product_offers, extract_package_weight
+from app.services.amazon.scraper_utils import (
+    get_headers as _get_headers,
+    normalize_price as _normalize_price,
+    parse_int as _parse_int,
+    parse_number as _parse_number,
+)
+
+
+def _extract_upc(soup: BeautifulSoup) -> Optional[str]:
+    """Extract UPC/EAN/GTIN from Amazon product detail sections."""
+    for row in soup.find_all("tr"):
+        th = row.find("th")
+        td = row.find("td")
+        if not th or not td:
+            continue
+        label = th.get_text(strip=True).lower()
+        if any(k in label for k in ("upc", "ean", "gtin")):
+            digits = re.sub(r"\D", "", td.get_text(strip=True))
+            if len(digits) >= 8:
+                return digits[:14]
+
+    for block in soup.select("#detailBullets_feature_div li, #productDetails_detailBullets_sections1 tr"):
+        text = block.get_text(" ", strip=True)
+        lower = text.lower()
+        if "upc" in lower or "ean" in lower or "gtin" in lower:
+            match = re.search(r"(\d{8,14})", text)
+            if match:
+                return match.group(1)
+
+    for script in soup.find_all("script", type="application/ld+json"):
+        raw = script.string or script.get_text()
+        if not raw or "gtin" not in raw.lower():
+            continue
+        match = re.search(r'"gtin(?:12|13|14)?"\s*:\s*"(\d{8,14})"', raw, re.I)
+        if match:
+            return match.group(1)
+    return None
+
+def get_mock_product(asin: str) -> dict:
+    data = {
+        "asin": asin,
+        "title": f"Amazon Product {asin}",
+        "brand": "Amazon Brand",
+        "category": "Electronics",
+        "price": 29.99,
+        "rating": 4.3,
+        "review_count": 1250,
+        "bsr": 5000,
+        "image_url": f"https://via.placeholder.com/300x300?text={asin}",
+        "amazon_url": f"https://www.amazon.com/dp/{asin}",
+        "in_stock": True,
+        "is_prime": True,
+        "buy_box_winner": "Amazon.com",
+        "buy_box_price": 29.99,
+        "buy_box_is_fba": True,
+        "buy_box_is_prime": True,
+        "seller_count": 3,
+        "fba_seller_count": 3,
+        "is_amazon_sold": True,
+        "has_buy_box": True,
+        "upc": "012345678905",
+        "other_sellers": [
+            {"name": "Seller A", "price": 31.99, "is_fba": True, "rating": "97%"},
+            {"name": "Seller B", "price": 32.50, "is_fba": False, "rating": "94%"},
+        ],
+        "data_source": "mock",
+    }
+    return data
+
+
+def _mock_or_none(asin: str) -> Optional[dict]:
+    if settings.allow_mock_data:
+        return get_mock_product(asin)
+    return None
+
+
+def _fetch_html(url: str, timeout: int = 60) -> Optional[str]:
+    """Fetch Amazon HTML — ScraperAPI on cloud servers, direct fetch as fallback."""
+    if settings.scraper_api_key:
+        try:
+            resp = requests.get(
+                "https://api.scraperapi.com",
+                params={
+                    "api_key": settings.scraper_api_key,
+                    "url": url,
+                    "country_code": "us",
+                },
+                timeout=timeout,
+            )
+            if resp.status_code == 200 and len(resp.text) > 500:
+                return resp.text
+            print(f"[scraper] ScraperAPI HTTP {resp.status_code} for {url[:70]}")
+        except Exception as e:
+            print(f"[scraper] ScraperAPI error: {e}")
+
+    try:
+        time.sleep(random.uniform(1.0, 2.5))
+        session = requests.Session()
+        try:
+            session.get("https://www.amazon.com", headers=_get_headers(), timeout=8)
+            time.sleep(random.uniform(0.5, 1.0))
+        except Exception:
+            pass
+        resp = session.get(url, headers=_get_headers(), timeout=12)
+        if resp.status_code == 200:
+            return resp.text
+    except Exception as e:
+        print(f"[scraper] Direct fetch error: {e}")
+    return None
+
+
+def scrape_amazon_product(asin: str) -> Optional[dict]:
+    url = f"https://www.amazon.com/dp/{asin}"
+    for attempt in range(2):
+        try:
+            html = _fetch_html(url)
+            if not html:
+                time.sleep(2)
+                continue
+
+            soup = BeautifulSoup(html, "html.parser")
+            page_text = soup.get_text().lower()
+
+            if "enter the characters you see below" in page_text or "sorry, we just need to make sure" in page_text:
+                return _mock_or_none(asin)
+
+            # ── Title ─────────────────────────────────────────────────────────
+            title = None
+            title_el = (
+                soup.find("span", id="productTitle") or
+                soup.find("h1", id="title") or
+                soup.find("span", {"class": "product-title-word-break"})
+            )
+            if title_el:
+                title = title_el.get_text(strip=True)
+            if not title:
+                return _mock_or_none(asin)
+
+            # ── Price ─────────────────────────────────────────────────────────
+            price = None
+            for tag, attrs in [
+                ("span", {"class": "a-price-whole"}),
+                ("span", {"id": "priceblock_ourprice"}),
+                ("span", {"id": "priceblock_dealprice"}),
+                ("span", {"class": "a-offscreen"}),
+            ]:
+                el = soup.find(tag, attrs)
+                if el:
+                    raw = _parse_number(el.get_text())
+                    if raw and raw > 0:
+                        price = raw
+                        break
+            price = _normalize_price(price)
+
+            # ── Rating ────────────────────────────────────────────────────────
+            rating = None
+            rating_el = (
+                soup.find("span", {"data-hook": "rating-out-of-text"}) or
+                soup.find("span", {"class": "a-icon-alt"}) or
+                soup.find("i", {"data-hook": "average-star-rating"})
+            )
+            if rating_el:
+                match = re.search(r"(\d+\.?\d*)\s*out of", rating_el.get_text())
+                if match:
+                    rating = float(match.group(1))
+
+            # ── Reviews ───────────────────────────────────────────────────────
+            review_count = None
+            review_el = (
+                soup.find("span", {"id": "acrCustomerReviewText"}) or
+                soup.find("span", {"data-hook": "total-review-count"})
+            )
+            if review_el:
+                review_count = _parse_int(review_el.get_text())
+
+            # ── BSR ───────────────────────────────────────────────────────────
+            bsr = None
+            bsr_section = soup.find("th", string=re.compile(r"Best Sellers Rank", re.I))
+            if not bsr_section:
+                bsr_section = soup.find("span", string=re.compile(r"Best Sellers Rank", re.I))
+            if bsr_section:
+                bsr_td = bsr_section.find_next("td") or bsr_section.find_next("span")
+                if bsr_td:
+                    match = re.search(r"#([\d,]+)", bsr_td.get_text())
+                    if match:
+                        bsr = _parse_int(match.group(1))
+            if not bsr:
+                for row in soup.find_all("tr"):
+                    th = row.find("th")
+                    td = row.find("td")
+                    if th and td and "best sellers rank" in th.get_text().lower():
+                        match = re.search(r"#([\d,]+)", td.get_text())
+                        if match:
+                            bsr = _parse_int(match.group(1))
+                            break
+
+            # ── Brand ─────────────────────────────────────────────────────────
+            brand = None
+            brand_el = soup.find("a", {"id": "bylineInfo"}) or soup.find("span", {"class": "author"})
+            if brand_el:
+                brand = re.sub(r"^(Visit the |Brand: )", "", brand_el.get_text(strip=True)).strip()
+                brand = re.sub(r"\s+Store$", "", brand, flags=re.I).strip()
+
+            # ── UPC ───────────────────────────────────────────────────────────
+            upc = _extract_upc(soup)
+
+            # ── Category ──────────────────────────────────────────────────────
+            category = None
+            breadcrumb = soup.find("div", {"id": "wayfinding-breadcrumbs_feature_div"})
+            if breadcrumb:
+                crumbs = breadcrumb.find_all("a")
+                if crumbs:
+                    category = crumbs[0].get_text(strip=True)
+
+            # ── Image ─────────────────────────────────────────────────────────
+            image_url = None
+            img_el = soup.find("img", {"id": "landingImage"}) or soup.find("img", {"id": "imgBlkFront"})
+            if img_el:
+                image_url = img_el.get("src") or img_el.get("data-old-hires")
+
+            # ── In Stock ──────────────────────────────────────────────────────
+            in_stock = True
+            availability_el = soup.find("div", {"id": "availability"})
+            if availability_el:
+                avail_text = availability_el.get_text(strip=True).lower()
+                in_stock = "in stock" in avail_text or "available" in avail_text
+
+            # ── Is Prime ──────────────────────────────────────────────────────
+            is_prime = soup.find("i", {"class": "a-icon-prime"}) is not None
+
+            # ════════════════════════════════════════════════════════════════
+            # BUY BOX DATA
+            # ════════════════════════════════════════════════════════════════
+
+            buy_box_winner = None
+            buy_box_price = price
+            buy_box_is_fba = False
+            buy_box_is_prime = is_prime
+            is_amazon_sold = False
+            seller_count = 1
+            fba_seller_count = 0
+            other_sellers = []
+            has_buy_box = True
+
+            # Who owns the buy box
+            merchant_el = (
+                soup.find("div", {"id": "merchant-info"}) or
+                soup.find("a", {"id": "sellerProfileTriggerId"}) or
+                soup.find("div", {"id": "tabular-buybox-truncate-0"})
+            )
+            if merchant_el:
+                merchant_text = merchant_el.get_text(strip=True)
+                if "amazon" in merchant_text.lower():
+                    buy_box_winner = "Amazon.com"
+                    is_amazon_sold = True
+                else:
+                    buy_box_winner = merchant_text[:50]
+
+            # Sold by Amazon check
+            sold_by_el = soup.find(string=re.compile(r"Sold by Amazon", re.I))
+            if sold_by_el:
+                buy_box_winner = "Amazon.com"
+                is_amazon_sold = True
+
+            # Ships from / sold by block
+            ships_block = soup.find("div", {"id": "tabular-buybox"})
+            if ships_block:
+                text = ships_block.get_text()
+                if "amazon" in text.lower():
+                    is_amazon_sold = True
+                    buy_box_winner = buy_box_winner or "Amazon.com"
+
+            # FBA check
+            fba_el = soup.find(string=re.compile(r"Fulfilled by Amazon", re.I))
+            if fba_el:
+                buy_box_is_fba = True
+
+            # FBM check — overrides if explicitly merchant fulfilled
+            fbm_el = soup.find(string=re.compile(r"Fulfillment by Merchant|Ships from.*sold by", re.I))
+            if fbm_el and not fba_el:
+                buy_box_is_fba = False
+
+            # Number of other sellers
+            sellers_el = soup.find("a", {"id": "olp-sl-new"}) or soup.find("span", string=re.compile(r"new from", re.I))
+            if sellers_el:
+                match = re.search(r"(\d+)", sellers_el.get_text())
+                if match:
+                    seller_count = int(match.group(1))
+
+            # Offer listing page — get other sellers
+            offer_el = soup.find("a", href=re.compile(r"/gp/offer-listing/"))
+            if offer_el:
+                offer_text = offer_el.get_text(strip=True)
+                match = re.search(r"(\d+)", offer_text)
+                if match:
+                    seller_count = max(seller_count, int(match.group(1)))
+
+            # Buy box price
+            buybox_price_el = (
+                soup.find("span", {"id": "price_inside_buybox"}) or
+                soup.find("span", {"id": "priceblock_ourprice"})
+            )
+            if buybox_price_el:
+                bb_price = _parse_number(buybox_price_el.get_text())
+                if bb_price:
+                    buy_box_price = _normalize_price(bb_price)
+
+            # Buy box availability
+            no_buybox_signals = (
+                soup.find("div", {"id": "outOfStock"})
+                or soup.find("span", {"id": "buybox-see-all-buying-choices"})
+                or soup.find(string=re.compile(r"no featured offers|currently unavailable", re.I))
+            )
+            add_to_cart = (
+                soup.find("input", {"id": "add-to-cart-button"})
+                or soup.find("span", {"id": "submit.add-to-cart"})
+                or soup.find("input", {"id": "buy-now-button"})
+            )
+            if no_buybox_signals and not add_to_cart:
+                has_buy_box = False
+            if not buy_box_price and not add_to_cart:
+                has_buy_box = False
+            if not in_stock:
+                has_buy_box = False
+
+            # Estimate FBA vs FBM seller split only when offers scrape did not run
+            if not other_sellers:
+                if buy_box_is_fba and has_buy_box:
+                    fba_seller_count = max(1, seller_count) if seller_count > 0 else 1
+                    fbm_seller_count = max(0, seller_count - fba_seller_count)
+                elif not buy_box_is_fba and has_buy_box:
+                    fbm_seller_count = max(1, seller_count) if seller_count > 0 else 1
+                    fba_seller_count = max(0, seller_count - fbm_seller_count)
+
+            package_weight_lbs = extract_package_weight(soup)
+
+            print(f"[scraper] ✅ {asin}: price=${price}, bsr={bsr}, rating={rating}, reviews={review_count}, buy_box={buy_box_winner}, sellers={seller_count}")
+
+            payload = {
+                "asin": asin,
+                "title": title,
+                "brand": brand or "Unknown",
+                "upc": upc,
+                "category": category or "General",
+                "image_url": image_url or "",
+                "amazon_url": url,
+                "price": price,
+                "bsr": bsr,
+                "rating": rating,
+                "review_count": review_count,
+                "in_stock": in_stock,
+                "is_prime": is_prime,
+                # Buy Box data
+                "buy_box_winner": buy_box_winner,
+                "buy_box_price": buy_box_price,
+                "buy_box_is_fba": buy_box_is_fba,
+                "buy_box_is_prime": buy_box_is_prime,
+                "seller_count": seller_count,
+                "fba_seller_count": fba_seller_count,
+                "fbm_seller_count": fbm_seller_count,
+                "has_buy_box": has_buy_box,
+                "is_amazon_sold": is_amazon_sold,
+                "other_sellers": other_sellers,
+                "package_weight_lbs": package_weight_lbs,
+                "data_source": "live",
+            }
+
+            if not buy_box_winner and has_buy_box:
+                buy_box_winner = "3rd Party Seller" if not is_amazon_sold else "Amazon.com"
+                payload["buy_box_winner"] = buy_box_winner
+            elif not has_buy_box:
+                payload["buy_box_winner"] = None
+                payload["buy_box_price"] = None
+
+            return enrich_product_offers(payload)
+
+        except requests.exceptions.Timeout:
+            time.sleep(2)
+        except requests.exceptions.RequestException:
+            time.sleep(2)
+        except Exception as e:
+            print(f"[scraper] Unexpected error: {e}")
+            return _mock_or_none(asin)
+
+    return _mock_or_none(asin)
+
+
+def search_asin_by_keyword(keyword: str) -> Optional[str]:
+    """Find the first ASIN from Amazon search results for a keyword."""
+    if not keyword or not keyword.strip():
+        return None
+    q = requests.utils.quote(keyword.strip())
+    url = f"https://www.amazon.com/s?k={q}"
+    try:
+        html = _fetch_html(url, timeout=45)
+        if not html:
+            return None
+        soup = BeautifulSoup(html, "html.parser")
+        for link in soup.find_all("a", href=True):
+            match = re.search(r"/dp/([A-Z0-9]{10})", link["href"])
+            if match:
+                return match.group(1)
+            match = re.search(r"/gp/product/([A-Z0-9]{10})", link["href"])
+            if match:
+                return match.group(1)
+    except Exception as e:
+        print(f"[scraper] Keyword search error: {e}")
     return None

app/services/amazon/sales_estimator.py

@@ -1,74 +1,74 @@
-CATEGORY_CURVES = {
-    "home": [(1,45000),(100,7000),(1000,1400),(5000,380),(10000,180),(50000,30)],
-    "electronics": [(1,30000),(100,4000),(1000,800),(5000,200),(10000,90),(50000,15)],
-    "clothing": [(1,60000),(100,8000),(1000,1600),(5000,430),(10000,200),(50000,35)],
-    "sports": [(1,25000),(100,3200),(1000,650),(5000,160),(10000,75),(50000,12)],
-    "beauty": [(1,50000),(100,7500),(1000,1500),(5000,400),(10000,185),(50000,32)],
-    "toys": [(1,35000),(100,5000),(1000,1000),(5000,260),(10000,120),(50000,20)],
-    "books": [(1,3000),(100,450),(1000,80),(5000,18),(10000,8)],
-    "default": [(1,30000),(100,4200),(1000,850),(5000,215),(10000,100),(50000,17)],
-}
-
-def interpolate_sales(bsr: int, curve: list) -> int:
-    if bsr <= 0:
-        return 0
-    curve = sorted(curve, key=lambda x: x[0])
-    if bsr <= curve[0][0]:
-        return curve[0][1]
-    if bsr >= curve[-1][0]:
-        return max(0, curve[-1][1])
-    for i in range(len(curve) - 1):
-        bsr_low, sales_high = curve[i]
-        bsr_high, sales_low = curve[i + 1]
-        if bsr_low <= bsr <= bsr_high:
-            ratio = (bsr - bsr_low) / (bsr_high - bsr_low)
-            return max(0, int(sales_high - ratio * (sales_high - sales_low)))
-    return 0
-
-def estimate_monthly_sales(bsr: int, category: str) -> dict:
-    if not bsr or bsr <= 0:
-        return {"monthly_units": None, "confidence": "low"}
-    
-    category_lower = (category or "").lower()
-    curve = CATEGORY_CURVES["default"]
-    confidence = "medium"
-    
-    for key, cat_curve in CATEGORY_CURVES.items():
-        if key != "default" and key in category_lower:
-            curve = cat_curve
-            confidence = "high"
-            break
-    
-    monthly_units = interpolate_sales(bsr, curve)
-    return {"monthly_units": monthly_units, "confidence": confidence}
-
-def calculate_opportunity_score(bsr, review_count, monthly_sales, seller_count) -> float:
-    score = 0
-    
-    # Demand (30 pts)
-    if monthly_sales >= 3000: score += 30
-    elif monthly_sales >= 1500: score += 23
-    elif monthly_sales >= 800: score += 17
-    elif monthly_sales >= 300: score += 10
-    elif monthly_sales >= 100: score += 5
-    
-    # Low competition reviews (30 pts)
-    if review_count < 100: score += 30
-    elif review_count < 500: score += 22
-    elif review_count < 1000: score += 15
-    elif review_count < 3000: score += 8
-    elif review_count < 8000: score += 3
-    
-    # BSR strength (20 pts)
-    if bsr < 1000: score += 20
-    elif bsr < 5000: score += 15
-    elif bsr < 15000: score += 10
-    elif bsr < 50000: score += 5
-    
-    # Seller count (20 pts)
-    if seller_count <= 1: score += 20
-    elif seller_count <= 3: score += 15
-    elif seller_count <= 8: score += 10
-    elif seller_count <= 15: score += 5
-    
+CATEGORY_CURVES = {
+    "home": [(1,45000),(100,7000),(1000,1400),(5000,380),(10000,180),(50000,30)],
+    "electronics": [(1,30000),(100,4000),(1000,800),(5000,200),(10000,90),(50000,15)],
+    "clothing": [(1,60000),(100,8000),(1000,1600),(5000,430),(10000,200),(50000,35)],
+    "sports": [(1,25000),(100,3200),(1000,650),(5000,160),(10000,75),(50000,12)],
+    "beauty": [(1,50000),(100,7500),(1000,1500),(5000,400),(10000,185),(50000,32)],
+    "toys": [(1,35000),(100,5000),(1000,1000),(5000,260),(10000,120),(50000,20)],
+    "books": [(1,3000),(100,450),(1000,80),(5000,18),(10000,8)],
+    "default": [(1,30000),(100,4200),(1000,850),(5000,215),(10000,100),(50000,17)],
+}
+
+def interpolate_sales(bsr: int, curve: list) -> int:
+    if bsr <= 0:
+        return 0
+    curve = sorted(curve, key=lambda x: x[0])
+    if bsr <= curve[0][0]:
+        return curve[0][1]
+    if bsr >= curve[-1][0]:
+        return max(0, curve[-1][1])
+    for i in range(len(curve) - 1):
+        bsr_low, sales_high = curve[i]
+        bsr_high, sales_low = curve[i + 1]
+        if bsr_low <= bsr <= bsr_high:
+            ratio = (bsr - bsr_low) / (bsr_high - bsr_low)
+            return max(0, int(sales_high - ratio * (sales_high - sales_low)))
+    return 0
+
+def estimate_monthly_sales(bsr: int, category: str) -> dict:
+    if not bsr or bsr <= 0:
+        return {"monthly_units": None, "confidence": "low"}
+    
+    category_lower = (category or "").lower()
+    curve = CATEGORY_CURVES["default"]
+    confidence = "medium"
+    
+    for key, cat_curve in CATEGORY_CURVES.items():
+        if key != "default" and key in category_lower:
+            curve = cat_curve
+            confidence = "high"
+            break
+    
+    monthly_units = interpolate_sales(bsr, curve)
+    return {"monthly_units": monthly_units, "confidence": confidence}
+
+def calculate_opportunity_score(bsr, review_count, monthly_sales, seller_count) -> float:
+    score = 0
+    
+    # Demand (30 pts)
+    if monthly_sales >= 3000: score += 30
+    elif monthly_sales >= 1500: score += 23
+    elif monthly_sales >= 800: score += 17
+    elif monthly_sales >= 300: score += 10
+    elif monthly_sales >= 100: score += 5
+    
+    # Low competition reviews (30 pts)
+    if review_count < 100: score += 30
+    elif review_count < 500: score += 22
+    elif review_count < 1000: score += 15
+    elif review_count < 3000: score += 8
+    elif review_count < 8000: score += 3
+    
+    # BSR strength (20 pts)
+    if bsr < 1000: score += 20
+    elif bsr < 5000: score += 15
+    elif bsr < 15000: score += 10
+    elif bsr < 50000: score += 5
+    
+    # Seller count (20 pts)
+    if seller_count <= 1: score += 20
+    elif seller_count <= 3: score += 15
+    elif seller_count <= 8: score += 10
+    elif seller_count <= 15: score += 5
+    
     return round(min(100, score), 1)

app/services/amazon/scraper_utils.py

@@ -1,55 +1,55 @@
-"""Shared HTTP/parsing helpers for Amazon scrapers (avoids circular imports)."""
-from __future__ import annotations
-
-import random
-import re
-from typing import Optional
-
-USER_AGENTS = [
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0",
-]
-
-
-def get_headers() -> dict:
-    return {
-        "User-Agent": random.choice(USER_AGENTS),
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.9",
-        "Accept-Encoding": "gzip, deflate, br",
-        "DNT": "1",
-        "Connection": "keep-alive",
-        "Upgrade-Insecure-Requests": "1",
-        "Sec-Fetch-Dest": "document",
-        "Sec-Fetch-Mode": "navigate",
-        "Sec-Fetch-Site": "none",
-        "Cache-Control": "max-age=0",
-    }
-
-
-def parse_number(text: str) -> Optional[float]:
-    if not text:
-        return None
-    cleaned = re.sub(r"[^\d.]", "", text.replace(",", ""))
-    try:
-        return float(cleaned) if cleaned else None
-    except ValueError:
-        return None
-
-
-def parse_int(text: str) -> Optional[int]:
-    val = parse_number(text)
-    return int(val) if val is not None else None
-
-
-def normalize_price(price: Optional[float]) -> Optional[float]:
-    """Convert PKR to USD if price is too large."""
-    if price is None:
-        return None
-    if price > 500:
-        usd = round(price / 278, 2)
-        print(f"[scraper] Price {price} looks like PKR, converting to USD: ${usd}")
-        return usd
-    return price
+"""Shared HTTP/parsing helpers for Amazon scrapers (avoids circular imports)."""
+from __future__ import annotations
+
+import random
+import re
+from typing import Optional
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0",
+]
+
+
+def get_headers() -> dict:
+    return {
+        "User-Agent": random.choice(USER_AGENTS),
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Accept-Encoding": "gzip, deflate, br",
+        "DNT": "1",
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "Sec-Fetch-Dest": "document",
+        "Sec-Fetch-Mode": "navigate",
+        "Sec-Fetch-Site": "none",
+        "Cache-Control": "max-age=0",
+    }
+
+
+def parse_number(text: str) -> Optional[float]:
+    if not text:
+        return None
+    cleaned = re.sub(r"[^\d.]", "", text.replace(",", ""))
+    try:
+        return float(cleaned) if cleaned else None
+    except ValueError:
+        return None
+
+
+def parse_int(text: str) -> Optional[int]:
+    val = parse_number(text)
+    return int(val) if val is not None else None
+
+
+def normalize_price(price: Optional[float]) -> Optional[float]:
+    """Convert PKR to USD if price is too large."""
+    if price is None:
+        return None
+    if price > 500:
+        usd = round(price / 278, 2)
+        print(f"[scraper] Price {price} looks like PKR, converting to USD: ${usd}")
+        return usd
+    return price

app/services/analytics/advanced_services.py

@@ -1,360 +1,360 @@
-import re
-import math
-from typing import Optional
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 1. SALES ESTIMATOR v2 — category-specific BSR → monthly sales
-# ══════════════════════════════════════════════════════════════════════════════
-
-CATEGORY_MULTIPLIERS = {
-    "kitchen": {"base": 8000, "decay": 0.55},
-    "home":    {"base": 7000, "decay": 0.55},
-    "sports":  {"base": 6000, "decay": 0.52},
-    "toys":    {"base": 9000, "decay": 0.58},
-    "beauty":  {"base": 7500, "decay": 0.54},
-    "health":  {"base": 6500, "decay": 0.53},
-    "tools":   {"base": 5000, "decay": 0.50},
-    "office":  {"base": 5500, "decay": 0.51},
-    "pet":     {"base": 6000, "decay": 0.52},
-    "garden":  {"base": 4500, "decay": 0.50},
-    "default": {"base": 6000, "decay": 0.52},
-}
-
-def estimate_sales_v2(bsr: int, category: str = "default", price: float = 25.0) -> dict:
-    cat = CATEGORY_MULTIPLIERS.get(category.lower(), CATEGORY_MULTIPLIERS["default"])
-    if bsr <= 0:
-        bsr = 50000
-    monthly_sales = int(cat["base"] * math.pow(bsr, -cat["decay"]) * 1000)
-    monthly_sales = max(1, min(monthly_sales, 50000))
-    monthly_revenue = round(monthly_sales * price, 2)
-    daily_sales = round(monthly_sales / 30, 1)
-
-    # Confidence based on BSR range
-    if bsr < 5000:
-        confidence = "High"
-    elif bsr < 50000:
-        confidence = "Medium"
-    else:
-        confidence = "Low"
-
-    return {
-        "monthly_sales": monthly_sales,
-        "daily_sales": daily_sales,
-        "monthly_revenue": monthly_revenue,
-        "confidence": confidence,
-        "category": category,
-        "bsr": bsr,
-        "price": price,
-        "annual_revenue": round(monthly_revenue * 12, 2),
-    }
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 2. REVIEW ANALYZER — sentiment + patterns
-# ══════════════════════════════════════════════════════════════════════════════
-
-POSITIVE_WORDS = ["great","excellent","perfect","love","amazing","best","good","quality","easy","fast","recommend","happy","pleased","works","nice","fantastic","awesome","solid","durable","comfortable"]
-NEGATIVE_WORDS = ["poor","bad","terrible","worst","broken","useless","cheap","waste","disappointed","defective","fragile","flimsy","slow","wrong","missing","return","refund","fake","stopped","horrible"]
-QUALITY_WORDS  = ["quality","durable","sturdy","solid","premium","cheap","flimsy","fragile","well-made","poorly made"]
-DELIVERY_WORDS = ["fast","quick","slow","delivery","shipping","arrived","late","early","package","damaged"]
-VALUE_WORDS    = ["worth","value","price","expensive","cheap","affordable","overpriced","deal","bargain"]
-
-def analyze_reviews(rating: float, review_count: int, title: str = "") -> dict:
-    """Analyze product based on available data — real NLP would need actual review text."""
-
-    # Star distribution estimate
-    if rating >= 4.5:
-        stars = {"5": 70, "4": 20, "3": 5, "2": 3, "1": 2}
-    elif rating >= 4.0:
-        stars = {"5": 55, "4": 25, "3": 10, "2": 5, "1": 5}
-    elif rating >= 3.5:
-        stars = {"5": 40, "4": 25, "3": 15, "2": 10, "1": 10}
-    elif rating >= 3.0:
-        stars = {"5": 30, "4": 20, "3": 20, "2": 15, "1": 15}
-    else:
-        stars = {"5": 20, "4": 15, "3": 15, "2": 20, "1": 30}
-
-    positive_pct = stars["5"] + stars["4"]
-    negative_pct = stars["1"] + stars["2"]
-
-    # Sentiment
-    if rating >= 4.3:
-        sentiment = "Very Positive"
-        sentiment_color = "#34d399"
-    elif rating >= 3.8:
-        sentiment = "Positive"
-        sentiment_color = "#86efac"
-    elif rating >= 3.3:
-        sentiment = "Mixed"
-        sentiment_color = "#fbbf24"
-    elif rating >= 2.8:
-        sentiment = "Negative"
-        sentiment_color = "#fb923c"
-    else:
-        sentiment = "Very Negative"
-        sentiment_color = "#f87171"
-
-    # Review velocity
-    if review_count > 10000:
-        velocity = "Saturated"
-    elif review_count > 1000:
-        velocity = "High"
-    elif review_count > 200:
-        velocity = "Medium"
-    elif review_count > 50:
-        velocity = "Growing"
-    else:
-        velocity = "Low"
-
-    # Market opportunity from reviews
-    if review_count < 100 and rating >= 4.0:
-        opportunity = "High — low reviews, good rating. Easy entry."
-    elif review_count < 500 and rating >= 3.8:
-        opportunity = "Medium — manageable competition."
-    elif review_count > 1000 and rating < 3.8:
-        opportunity = "Medium — saturated but poor quality. Can disrupt."
-    elif review_count > 1000 and rating >= 4.2:
-        opportunity = "Low — strong competition, hard to enter."
-    else:
-        opportunity = "Medium — assess further."
-
-    return {
-        "rating": rating,
-        "review_count": review_count,
-        "sentiment": sentiment,
-        "sentiment_color": sentiment_color,
-        "positive_pct": positive_pct,
-        "negative_pct": negative_pct,
-        "star_distribution": stars,
-        "review_velocity": velocity,
-        "market_opportunity": opportunity,
-        "common_positives": ["Good quality", "Fast delivery", "Value for money", "Easy to use", "As described"][:3],
-        "common_negatives": ["Quality issues", "Poor packaging", "Not as described"][:2] if negative_pct > 15 else [],
-        "entry_barrier": "Low" if review_count < 100 else "Medium" if review_count < 500 else "High",
-        "entry_barrier_color": "#34d399" if review_count < 100 else "#fbbf24" if review_count < 500 else "#f87171",
-    }
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 3. BUY BOX ANALYZER
-# ══════════════════════════════════════════════════════════════════════════════
-
-def analyze_buy_box(price: float, rating: float, review_count: int, is_fba: bool = True, is_prime: bool = True) -> dict:
-    score = 0
-    factors = []
-
-    # Price competitiveness
-    if price < 20:
-        score += 25
-        factors.append({"factor": "Price", "status": "Competitive", "color": "#34d399", "detail": f"${price:.2f} — low price helps win buy box"})
-    elif price < 50:
-        score += 20
-        factors.append({"factor": "Price", "status": "Moderate", "color": "#fbbf24", "detail": f"${price:.2f} — average price range"})
-    else:
-        score += 10
-        factors.append({"factor": "Price", "status": "High", "color": "#f87171", "detail": f"${price:.2f} — high price hurts buy box chances"})
-
-    # FBA
-    if is_fba:
-        score += 30
-        factors.append({"factor": "Fulfillment", "status": "FBA ✓", "color": "#34d399", "detail": "FBA strongly favored for buy box"})
-    else:
-        score += 5
-        factors.append({"factor": "Fulfillment", "status": "FBM", "color": "#f87171", "detail": "FBM sellers rarely win buy box"})
-
-    # Prime
-    if is_prime:
-        score += 20
-        factors.append({"factor": "Prime", "status": "Eligible ✓", "color": "#34d399", "detail": "Prime eligibility required for buy box"})
-    else:
-        score += 0
-        factors.append({"factor": "Prime", "status": "Not Eligible", "color": "#f87171", "detail": "No Prime = very low buy box chance"})
-
-    # Seller rating
-    if rating >= 4.5:
-        score += 15
-        factors.append({"factor": "Seller Rating", "status": "Excellent", "color": "#34d399", "detail": f"{rating}★ — Amazon favors high-rated sellers"})
-    elif rating >= 4.0:
-        score += 10
-        factors.append({"factor": "Seller Rating", "status": "Good", "color": "#fbbf24", "detail": f"{rating}★ — acceptable for buy box"})
-    else:
-        score += 3
-        factors.append({"factor": "Seller Rating", "status": "Needs Work", "color": "#f87171", "detail": f"{rating}★ — low rating hurts buy box"})
-
-    # Review count
-    if review_count > 100:
-        score += 10
-        factors.append({"factor": "Reviews", "status": "Established", "color": "#34d399", "detail": f"{review_count:,} reviews — trusted seller signal"})
-    else:
-        score += 5
-        factors.append({"factor": "Reviews", "status": "New Seller", "color": "#fbbf24", "detail": f"{review_count} reviews — building trust"})
-
-    score = min(score, 100)
-
-    if score >= 75:
-        verdict = "Strong Buy Box Candidate"
-        verdict_color = "#34d399"
-    elif score >= 50:
-        verdict = "Moderate Chance"
-        verdict_color = "#fbbf24"
-    elif score >= 25:
-        verdict = "Low Chance"
-        verdict_color = "#fb923c"
-    else:
-        verdict = "Unlikely to Win"
-        verdict_color = "#f87171"
-
-    return {
-        "score": score,
-        "verdict": verdict,
-        "verdict_color": verdict_color,
-        "factors": factors,
-        "tips": [
-            "Use FBA for best buy box eligibility",
-            "Price within 2% of lowest FBA offer",
-            "Maintain 95%+ seller feedback rating",
-            "Keep order defect rate below 1%",
-            "Ship on time — late shipments hurt score",
-        ][:3]
-    }
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 4. NICHE FINDER
-# ══════════════════════════════════════════════════════════════════════════════
-
-def analyze_niche(keyword: str, avg_bsr: float, avg_reviews: float, avg_price: float, product_count: int = 100) -> dict:
-    # Demand score (lower BSR = higher demand)
-    if avg_bsr < 5000:
-        demand = 95
-    elif avg_bsr < 20000:
-        demand = 80
-    elif avg_bsr < 50000:
-        demand = 60
-    elif avg_bsr < 100000:
-        demand = 40
-    else:
-        demand = 20
-
-    # Competition score (lower reviews = less competition)
-    if avg_reviews < 50:
-        competition = 10   # low competition
-    elif avg_reviews < 200:
-        competition = 30
-    elif avg_reviews < 500:
-        competition = 55
-    elif avg_reviews < 1000:
-        competition = 75
-    else:
-        competition = 90
-
-    # Price attractiveness
-    if 20 <= avg_price <= 60:
-        price_score = 90
-        price_note = "Sweet spot for FBA ($20-$60)"
-    elif 10 <= avg_price < 20:
-        price_score = 60
-        price_note = "Low margin risk under $20"
-    elif 60 < avg_price <= 100:
-        price_score = 75
-        price_note = "Good margin, lower volume"
-    else:
-        price_score = 40
-        price_note = "High price = niche market"
-
-    # Opportunity score
-    opportunity = round((demand * 0.4) + ((100 - competition) * 0.4) + (price_score * 0.2))
-
-    if opportunity >= 70:
-        verdict = "🟢 Great Niche"
-        verdict_color = "#34d399"
-    elif opportunity >= 50:
-        verdict = "🟡 Decent Niche"
-        verdict_color = "#fbbf24"
-    elif opportunity >= 35:
-        verdict = "🟠 Challenging"
-        verdict_color = "#fb923c"
-    else:
-        verdict = "🔴 Avoid"
-        verdict_color = "#f87171"
-
-    est_monthly_sales = estimate_sales_v2(int(avg_bsr), price=avg_price)["monthly_sales"]
-    market_size = round(est_monthly_sales * avg_price * product_count / 1000, 0)
-
-    return {
-        "keyword": keyword,
-        "opportunity_score": opportunity,
-        "verdict": verdict,
-        "verdict_color": verdict_color,
-        "demand_score": demand,
-        "competition_score": competition,
-        "price_score": price_score,
-        "price_note": price_note,
-        "avg_bsr": int(avg_bsr),
-        "avg_reviews": int(avg_reviews),
-        "avg_price": avg_price,
-        "est_monthly_sales": est_monthly_sales,
-        "market_size_k": market_size,
-        "recommendation": (
-            "Low competition — great entry opportunity!" if competition < 30
-            else "Medium competition — differentiate product." if competition < 60
-            else "High competition — need strong differentiation."
-        )
-    }
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 5. KEYWORD RESEARCH
-# ══════════════════════════════════════════════════════════════════════════════
-
-def generate_keywords(seed_keyword: str, category: str = "") -> dict:
-    seed = seed_keyword.lower().strip()
-    words = seed.split()
-
-    # Generate variations
-    modifiers_prefix = ["best", "top", "premium", "cheap", "professional", "heavy duty", "large", "small", "portable", "electric"]
-    modifiers_suffix = ["for home", "for kitchen", "for office", "set", "kit", "bundle", "with lid", "non stick", "stainless steel", "organic"]
-
-    keywords = []
-
-    # Main keyword
-    keywords.append({
-        "keyword": seed,
-        "search_volume": "High",
-        "competition": "High",
-        "opportunity": "Low",
-        "type": "Head"
-    })
-
-    # Long tail variations
-    for mod in modifiers_prefix[:5]:
-        kw = f"{mod} {seed}"
-        keywords.append({
-            "keyword": kw,
-            "search_volume": "Medium",
-            "competition": "Medium",
-            "opportunity": "Medium",
-            "type": "Long-tail"
-        })
-
-    for mod in modifiers_suffix[:5]:
-        kw = f"{seed} {mod}"
-        keywords.append({
-            "keyword": kw,
-            "search_volume": "Low",
-            "competition": "Low",
-            "opportunity": "High",
-            "type": "Long-tail"
-        })
-
-    # Backend keywords (for listing)
-    backend = [seed] + words + [f"{words[-1]} set", f"buy {seed}", f"{seed} amazon"]
-
-    return {
-        "seed_keyword": seed,
-        "total_keywords": len(keywords),
-        "keywords": keywords,
-        "backend_keywords": backend,
-        "top_opportunity": [k for k in keywords if k["opportunity"] == "High"][:3],
-        "tip": f"Target '{seed} for home' or '{seed} set' — lower competition, high buyer intent."
+import re
+import math
+from typing import Optional
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 1. SALES ESTIMATOR v2 — category-specific BSR → monthly sales
+# ══════════════════════════════════════════════════════════════════════════════
+
+CATEGORY_MULTIPLIERS = {
+    "kitchen": {"base": 8000, "decay": 0.55},
+    "home":    {"base": 7000, "decay": 0.55},
+    "sports":  {"base": 6000, "decay": 0.52},
+    "toys":    {"base": 9000, "decay": 0.58},
+    "beauty":  {"base": 7500, "decay": 0.54},
+    "health":  {"base": 6500, "decay": 0.53},
+    "tools":   {"base": 5000, "decay": 0.50},
+    "office":  {"base": 5500, "decay": 0.51},
+    "pet":     {"base": 6000, "decay": 0.52},
+    "garden":  {"base": 4500, "decay": 0.50},
+    "default": {"base": 6000, "decay": 0.52},
+}
+
+def estimate_sales_v2(bsr: int, category: str = "default", price: float = 25.0) -> dict:
+    cat = CATEGORY_MULTIPLIERS.get(category.lower(), CATEGORY_MULTIPLIERS["default"])
+    if bsr <= 0:
+        bsr = 50000
+    monthly_sales = int(cat["base"] * math.pow(bsr, -cat["decay"]) * 1000)
+    monthly_sales = max(1, min(monthly_sales, 50000))
+    monthly_revenue = round(monthly_sales * price, 2)
+    daily_sales = round(monthly_sales / 30, 1)
+
+    # Confidence based on BSR range
+    if bsr < 5000:
+        confidence = "High"
+    elif bsr < 50000:
+        confidence = "Medium"
+    else:
+        confidence = "Low"
+
+    return {
+        "monthly_sales": monthly_sales,
+        "daily_sales": daily_sales,
+        "monthly_revenue": monthly_revenue,
+        "confidence": confidence,
+        "category": category,
+        "bsr": bsr,
+        "price": price,
+        "annual_revenue": round(monthly_revenue * 12, 2),
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 2. REVIEW ANALYZER — sentiment + patterns
+# ══════════════════════════════════════════════════════════════════════════════
+
+POSITIVE_WORDS = ["great","excellent","perfect","love","amazing","best","good","quality","easy","fast","recommend","happy","pleased","works","nice","fantastic","awesome","solid","durable","comfortable"]
+NEGATIVE_WORDS = ["poor","bad","terrible","worst","broken","useless","cheap","waste","disappointed","defective","fragile","flimsy","slow","wrong","missing","return","refund","fake","stopped","horrible"]
+QUALITY_WORDS  = ["quality","durable","sturdy","solid","premium","cheap","flimsy","fragile","well-made","poorly made"]
+DELIVERY_WORDS = ["fast","quick","slow","delivery","shipping","arrived","late","early","package","damaged"]
+VALUE_WORDS    = ["worth","value","price","expensive","cheap","affordable","overpriced","deal","bargain"]
+
+def analyze_reviews(rating: float, review_count: int, title: str = "") -> dict:
+    """Analyze product based on available data — real NLP would need actual review text."""
+
+    # Star distribution estimate
+    if rating >= 4.5:
+        stars = {"5": 70, "4": 20, "3": 5, "2": 3, "1": 2}
+    elif rating >= 4.0:
+        stars = {"5": 55, "4": 25, "3": 10, "2": 5, "1": 5}
+    elif rating >= 3.5:
+        stars = {"5": 40, "4": 25, "3": 15, "2": 10, "1": 10}
+    elif rating >= 3.0:
+        stars = {"5": 30, "4": 20, "3": 20, "2": 15, "1": 15}
+    else:
+        stars = {"5": 20, "4": 15, "3": 15, "2": 20, "1": 30}
+
+    positive_pct = stars["5"] + stars["4"]
+    negative_pct = stars["1"] + stars["2"]
+
+    # Sentiment
+    if rating >= 4.3:
+        sentiment = "Very Positive"
+        sentiment_color = "#34d399"
+    elif rating >= 3.8:
+        sentiment = "Positive"
+        sentiment_color = "#86efac"
+    elif rating >= 3.3:
+        sentiment = "Mixed"
+        sentiment_color = "#fbbf24"
+    elif rating >= 2.8:
+        sentiment = "Negative"
+        sentiment_color = "#fb923c"
+    else:
+        sentiment = "Very Negative"
+        sentiment_color = "#f87171"
+
+    # Review velocity
+    if review_count > 10000:
+        velocity = "Saturated"
+    elif review_count > 1000:
+        velocity = "High"
+    elif review_count > 200:
+        velocity = "Medium"
+    elif review_count > 50:
+        velocity = "Growing"
+    else:
+        velocity = "Low"
+
+    # Market opportunity from reviews
+    if review_count < 100 and rating >= 4.0:
+        opportunity = "High — low reviews, good rating. Easy entry."
+    elif review_count < 500 and rating >= 3.8:
+        opportunity = "Medium — manageable competition."
+    elif review_count > 1000 and rating < 3.8:
+        opportunity = "Medium — saturated but poor quality. Can disrupt."
+    elif review_count > 1000 and rating >= 4.2:
+        opportunity = "Low — strong competition, hard to enter."
+    else:
+        opportunity = "Medium — assess further."
+
+    return {
+        "rating": rating,
+        "review_count": review_count,
+        "sentiment": sentiment,
+        "sentiment_color": sentiment_color,
+        "positive_pct": positive_pct,
+        "negative_pct": negative_pct,
+        "star_distribution": stars,
+        "review_velocity": velocity,
+        "market_opportunity": opportunity,
+        "common_positives": ["Good quality", "Fast delivery", "Value for money", "Easy to use", "As described"][:3],
+        "common_negatives": ["Quality issues", "Poor packaging", "Not as described"][:2] if negative_pct > 15 else [],
+        "entry_barrier": "Low" if review_count < 100 else "Medium" if review_count < 500 else "High",
+        "entry_barrier_color": "#34d399" if review_count < 100 else "#fbbf24" if review_count < 500 else "#f87171",
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 3. BUY BOX ANALYZER
+# ══════════════════════════════════════════════════════════════════════════════
+
+def analyze_buy_box(price: float, rating: float, review_count: int, is_fba: bool = True, is_prime: bool = True) -> dict:
+    score = 0
+    factors = []
+
+    # Price competitiveness
+    if price < 20:
+        score += 25
+        factors.append({"factor": "Price", "status": "Competitive", "color": "#34d399", "detail": f"${price:.2f} — low price helps win buy box"})
+    elif price < 50:
+        score += 20
+        factors.append({"factor": "Price", "status": "Moderate", "color": "#fbbf24", "detail": f"${price:.2f} — average price range"})
+    else:
+        score += 10
+        factors.append({"factor": "Price", "status": "High", "color": "#f87171", "detail": f"${price:.2f} — high price hurts buy box chances"})
+
+    # FBA
+    if is_fba:
+        score += 30
+        factors.append({"factor": "Fulfillment", "status": "FBA ✓", "color": "#34d399", "detail": "FBA strongly favored for buy box"})
+    else:
+        score += 5
+        factors.append({"factor": "Fulfillment", "status": "FBM", "color": "#f87171", "detail": "FBM sellers rarely win buy box"})
+
+    # Prime
+    if is_prime:
+        score += 20
+        factors.append({"factor": "Prime", "status": "Eligible ✓", "color": "#34d399", "detail": "Prime eligibility required for buy box"})
+    else:
+        score += 0
+        factors.append({"factor": "Prime", "status": "Not Eligible", "color": "#f87171", "detail": "No Prime = very low buy box chance"})
+
+    # Seller rating
+    if rating >= 4.5:
+        score += 15
+        factors.append({"factor": "Seller Rating", "status": "Excellent", "color": "#34d399", "detail": f"{rating}★ — Amazon favors high-rated sellers"})
+    elif rating >= 4.0:
+        score += 10
+        factors.append({"factor": "Seller Rating", "status": "Good", "color": "#fbbf24", "detail": f"{rating}★ — acceptable for buy box"})
+    else:
+        score += 3
+        factors.append({"factor": "Seller Rating", "status": "Needs Work", "color": "#f87171", "detail": f"{rating}★ — low rating hurts buy box"})
+
+    # Review count
+    if review_count > 100:
+        score += 10
+        factors.append({"factor": "Reviews", "status": "Established", "color": "#34d399", "detail": f"{review_count:,} reviews — trusted seller signal"})
+    else:
+        score += 5
+        factors.append({"factor": "Reviews", "status": "New Seller", "color": "#fbbf24", "detail": f"{review_count} reviews — building trust"})
+
+    score = min(score, 100)
+
+    if score >= 75:
+        verdict = "Strong Buy Box Candidate"
+        verdict_color = "#34d399"
+    elif score >= 50:
+        verdict = "Moderate Chance"
+        verdict_color = "#fbbf24"
+    elif score >= 25:
+        verdict = "Low Chance"
+        verdict_color = "#fb923c"
+    else:
+        verdict = "Unlikely to Win"
+        verdict_color = "#f87171"
+
+    return {
+        "score": score,
+        "verdict": verdict,
+        "verdict_color": verdict_color,
+        "factors": factors,
+        "tips": [
+            "Use FBA for best buy box eligibility",
+            "Price within 2% of lowest FBA offer",
+            "Maintain 95%+ seller feedback rating",
+            "Keep order defect rate below 1%",
+            "Ship on time — late shipments hurt score",
+        ][:3]
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 4. NICHE FINDER
+# ══════════════════════════════════════════════════════════════════════════════
+
+def analyze_niche(keyword: str, avg_bsr: float, avg_reviews: float, avg_price: float, product_count: int = 100) -> dict:
+    # Demand score (lower BSR = higher demand)
+    if avg_bsr < 5000:
+        demand = 95
+    elif avg_bsr < 20000:
+        demand = 80
+    elif avg_bsr < 50000:
+        demand = 60
+    elif avg_bsr < 100000:
+        demand = 40
+    else:
+        demand = 20
+
+    # Competition score (lower reviews = less competition)
+    if avg_reviews < 50:
+        competition = 10   # low competition
+    elif avg_reviews < 200:
+        competition = 30
+    elif avg_reviews < 500:
+        competition = 55
+    elif avg_reviews < 1000:
+        competition = 75
+    else:
+        competition = 90
+
+    # Price attractiveness
+    if 20 <= avg_price <= 60:
+        price_score = 90
+        price_note = "Sweet spot for FBA ($20-$60)"
+    elif 10 <= avg_price < 20:
+        price_score = 60
+        price_note = "Low margin risk under $20"
+    elif 60 < avg_price <= 100:
+        price_score = 75
+        price_note = "Good margin, lower volume"
+    else:
+        price_score = 40
+        price_note = "High price = niche market"
+
+    # Opportunity score
+    opportunity = round((demand * 0.4) + ((100 - competition) * 0.4) + (price_score * 0.2))
+
+    if opportunity >= 70:
+        verdict = "🟢 Great Niche"
+        verdict_color = "#34d399"
+    elif opportunity >= 50:
+        verdict = "🟡 Decent Niche"
+        verdict_color = "#fbbf24"
+    elif opportunity >= 35:
+        verdict = "🟠 Challenging"
+        verdict_color = "#fb923c"
+    else:
+        verdict = "🔴 Avoid"
+        verdict_color = "#f87171"
+
+    est_monthly_sales = estimate_sales_v2(int(avg_bsr), price=avg_price)["monthly_sales"]
+    market_size = round(est_monthly_sales * avg_price * product_count / 1000, 0)
+
+    return {
+        "keyword": keyword,
+        "opportunity_score": opportunity,
+        "verdict": verdict,
+        "verdict_color": verdict_color,
+        "demand_score": demand,
+        "competition_score": competition,
+        "price_score": price_score,
+        "price_note": price_note,
+        "avg_bsr": int(avg_bsr),
+        "avg_reviews": int(avg_reviews),
+        "avg_price": avg_price,
+        "est_monthly_sales": est_monthly_sales,
+        "market_size_k": market_size,
+        "recommendation": (
+            "Low competition — great entry opportunity!" if competition < 30
+            else "Medium competition — differentiate product." if competition < 60
+            else "High competition — need strong differentiation."
+        )
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 5. KEYWORD RESEARCH
+# ══════════════════════════════════════════════════════════════════════════════
+
+def generate_keywords(seed_keyword: str, category: str = "") -> dict:
+    seed = seed_keyword.lower().strip()
+    words = seed.split()
+
+    # Generate variations
+    modifiers_prefix = ["best", "top", "premium", "cheap", "professional", "heavy duty", "large", "small", "portable", "electric"]
+    modifiers_suffix = ["for home", "for kitchen", "for office", "set", "kit", "bundle", "with lid", "non stick", "stainless steel", "organic"]
+
+    keywords = []
+
+    # Main keyword
+    keywords.append({
+        "keyword": seed,
+        "search_volume": "High",
+        "competition": "High",
+        "opportunity": "Low",
+        "type": "Head"
+    })
+
+    # Long tail variations
+    for mod in modifiers_prefix[:5]:
+        kw = f"{mod} {seed}"
+        keywords.append({
+            "keyword": kw,
+            "search_volume": "Medium",
+            "competition": "Medium",
+            "opportunity": "Medium",
+            "type": "Long-tail"
+        })
+
+    for mod in modifiers_suffix[:5]:
+        kw = f"{seed} {mod}"
+        keywords.append({
+            "keyword": kw,
+            "search_volume": "Low",
+            "competition": "Low",
+            "opportunity": "High",
+            "type": "Long-tail"
+        })
+
+    # Backend keywords (for listing)
+    backend = [seed] + words + [f"{words[-1]} set", f"buy {seed}", f"{seed} amazon"]
+
+    return {
+        "seed_keyword": seed,
+        "total_keywords": len(keywords),
+        "keywords": keywords,
+        "backend_keywords": backend,
+        "top_opportunity": [k for k in keywords if k["opportunity"] == "High"][:3],
+        "tip": f"Target '{seed} for home' or '{seed} set' — lower competition, high buyer intent."
     }

app/services/analytics/ai_analyzer.py

@@ -1,188 +1,188 @@
-"""AI product analysis — LLM-powered with heuristic fallback."""
-from __future__ import annotations
-
-from typing import Any, Dict, List
-
-from app.services.llm_service import generate_json, get_active_provider, is_llm_available
-
-AI_ANALYSIS_SYSTEM = (
-    "You are Rankora AI, an expert Amazon FBA product research analyst. "
-    "Given structured product metrics, produce a JSON analysis for sellers deciding "
-    "whether to source and launch this product. Be specific, honest, and actionable. "
-    "Use ONLY the data provided — do not invent sales figures."
-)
-
-AI_ANALYSIS_SCHEMA = """
-{
-  "overall_signal": "emoji + short label e.g. Strong Buy Signal",
-  "summary": "2-3 sentence executive summary",
-  "action": "one clear next step",
-  "market_position": "Top Seller | Strong Performer | etc.",
-  "position_insight": "1-2 sentences",
-  "review_barrier": "Low | Medium | High | Very High",
-  "review_insight": "1-2 sentences",
-  "price_insight": "1-2 sentences",
-  "pricing_strategy": "actionable pricing advice",
-  "rating_insight": "1-2 sentences",
-  "quality_bar": "Low | Medium | High | Very High",
-  "recommendations": ["bullet 1", "bullet 2", "... up to 6"],
-  "llm_insights": ["deeper insight 1", "deeper insight 2", "... up to 4"],
-  "risk_factors": ["risk 1", "risk 2"],
-  "competitive_moat": "what protects incumbents or what gap exists"
-}
-"""
-
-
-def _heuristic_analysis(product_data: Dict[str, Any]) -> Dict[str, Any]:
-    """Rule-based analysis (no API key needed)."""
-    title = product_data.get("title", "")
-    price = product_data.get("current_price", 0) or 0
-    bsr = product_data.get("current_bsr", 0) or 0
-    rating = product_data.get("current_rating", 0) or 0
-    reviews = product_data.get("current_review_count", 0) or 0
-    monthly_sales = product_data.get("sales_estimate_monthly", 0) or 0
-    revenue = product_data.get("revenue_estimate_monthly", 0) or 0
-    score = product_data.get("opportunity_score", 0) or 0
-    category = product_data.get("category", "General") or "General"
-
-    if bsr <= 1000:
-        market_position = "Top Seller"
-        position_insight = "This product is in the top tier of Amazon sellers — extremely high demand but very competitive."
-    elif bsr <= 5000:
-        market_position = "Strong Performer"
-        position_insight = "Excellent sales velocity. High competition but proven market demand exists."
-    elif bsr <= 20000:
-        market_position = "Moderate Performer"
-        position_insight = "Solid product with consistent sales. Good entry point for new sellers."
-    elif bsr <= 100000:
-        market_position = "Niche Product"
-        position_insight = "Lower volume niche product. Less competition, but smaller market size."
-    else:
-        market_position = "Slow Mover"
-        position_insight = "Low sales velocity. May have seasonal demand or very specific audience."
-
-    if reviews >= 10000:
-        review_barrier = "Very High"
-        review_insight = f"With {reviews:,} reviews, breaking in is extremely difficult without significant investment."
-    elif reviews >= 1000:
-        review_barrier = "High"
-        review_insight = f"{reviews:,} reviews creates a significant trust barrier."
-    elif reviews >= 100:
-        review_barrier = "Medium"
-        review_insight = f"{reviews:,} reviews is manageable. Focus on getting first 50 reviews quickly."
-    else:
-        review_barrier = "Low"
-        review_insight = f"Only {reviews:,} reviews — great opportunity to compete with fresh listings."
-
-    if price >= 50:
-        price_insight = f"At ${price}, higher margins are possible. Customers expect premium quality."
-        pricing_strategy = "Premium positioning — invest in quality images and A+ content."
-    elif price >= 20:
-        price_insight = f"${price} is the sweet spot for Amazon FBA. Good margin potential."
-        pricing_strategy = "Competitive pricing — watch BSR changes when adjusting price by ±$2."
-    elif price >= 10:
-        price_insight = f"${price} is low margin territory after FBA fees."
-        pricing_strategy = "Consider bundling to improve margins."
-    else:
-        price_insight = f"At ${price}, FBA fees will consume most margin."
-        pricing_strategy = "High volume strategy required."
-
-    if rating >= 4.5:
-        rating_insight = f"{rating}★ rating is excellent. Match this quality to compete."
-        quality_bar = "Very High"
-    elif rating >= 4.0:
-        rating_insight = f"{rating}★ rating is good. Room to differentiate with better quality."
-        quality_bar = "High"
-    elif rating >= 3.5:
-        rating_insight = f"{rating}★ suggests customer dissatisfaction. Opportunity to do it better."
-        quality_bar = "Medium — Opportunity to differentiate"
-    else:
-        rating_insight = f"{rating}★ rating is poor. Strong opportunity if you solve core issues."
-        quality_bar = "Low — Big opportunity"
-
-    if score >= 70:
-        overall = "Strong Buy Signal"
-        summary = f"Promising opportunity in {category}. Strong sales velocity with manageable competition."
-        action = "Move forward with supplier sourcing. Test with a small initial order."
-    elif score >= 50:
-        overall = "Proceed with Caution"
-        summary = f"Moderate opportunity in {category}. Profitability possible but requires careful execution."
-        action = "Deep dive into top competitors before investing."
-    elif score >= 30:
-        overall = "Challenging Market"
-        summary = f"Difficult entry in {category}. High competition or low demand."
-        action = "Look for a sub-niche with less competition."
-    else:
-        overall = "Not Recommended"
-        summary = f"Unfavorable metrics in {category} for new entrants."
-        action = "Pass on this product."
-
-    recommendations: List[str] = []
-    if reviews < 50:
-        recommendations.append("Low review count — easier to rank with a new listing")
-    if rating < 4.0:
-        recommendations.append("Low rating — differentiate with better product quality")
-    if bsr > 50000:
-        recommendations.append("High BSR — validate demand before large investment")
-    if price > 30:
-        recommendations.append("Good price point — FBA margins should be healthy")
-    if monthly_sales > 500:
-        recommendations.append("High sales volume — proven market demand")
-    if score >= 60:
-        recommendations.append("Good opportunity score — worth serious consideration")
-
-    return {
-        "overall_signal": overall,
-        "summary": summary,
-        "action": action,
-        "market_position": market_position,
-        "position_insight": position_insight,
-        "review_barrier": review_barrier,
-        "review_insight": review_insight,
-        "price_insight": price_insight,
-        "pricing_strategy": pricing_strategy,
-        "rating_insight": rating_insight,
-        "quality_bar": quality_bar,
-        "recommendations": recommendations,
-        "llm_insights": [],
-        "risk_factors": [],
-        "competitive_moat": "",
-        "metrics_summary": {
-            "monthly_revenue": f"${revenue:,.0f}" if revenue else "N/A",
-            "monthly_units": f"~{monthly_sales:,}" if monthly_sales else "N/A",
-            "opportunity_score": score,
-            "market_position": market_position,
-        },
-        "used_llm": False,
-        "provider": "heuristic",
-        "engine": "rule-based",
-    }
-
-
-def generate_ai_analysis(product_data: Dict[str, Any]) -> Dict[str, Any]:
-    """Generate AI analysis — LLM when API key configured, else heuristics."""
-    base = _heuristic_analysis(product_data)
-
-    if not is_llm_available():
-        return base
-
-    import json
-
-    user_prompt = (
-        f"Analyze this Amazon product for an FBA seller.\n\n"
-        f"PRODUCT DATA:\n{json.dumps(product_data, default=str)}\n\n"
-        f"Return JSON matching this schema:\n{AI_ANALYSIS_SCHEMA}"
-    )
-
-    llm_data, provider = generate_json(AI_ANALYSIS_SYSTEM, user_prompt)
-    if not llm_data:
-        return base
-
-    merged = {**base, **{k: v for k, v in llm_data.items() if v is not None}}
-    merged["used_llm"] = True
-    merged["provider"] = provider or get_active_provider() or "llm"
-    merged["engine"] = "llm"
-    merged["metrics_summary"] = base["metrics_summary"]
-    if not merged.get("recommendations"):
-        merged["recommendations"] = base["recommendations"]
-    return merged
+"""AI product analysis — LLM-powered with heuristic fallback."""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from app.services.llm_service import generate_json, get_active_provider, is_llm_available
+
+AI_ANALYSIS_SYSTEM = (
+    "You are Rankora AI, an expert Amazon FBA product research analyst. "
+    "Given structured product metrics, produce a JSON analysis for sellers deciding "
+    "whether to source and launch this product. Be specific, honest, and actionable. "
+    "Use ONLY the data provided — do not invent sales figures."
+)
+
+AI_ANALYSIS_SCHEMA = """
+{
+  "overall_signal": "emoji + short label e.g. Strong Buy Signal",
+  "summary": "2-3 sentence executive summary",
+  "action": "one clear next step",
+  "market_position": "Top Seller | Strong Performer | etc.",
+  "position_insight": "1-2 sentences",
+  "review_barrier": "Low | Medium | High | Very High",
+  "review_insight": "1-2 sentences",
+  "price_insight": "1-2 sentences",
+  "pricing_strategy": "actionable pricing advice",
+  "rating_insight": "1-2 sentences",
+  "quality_bar": "Low | Medium | High | Very High",
+  "recommendations": ["bullet 1", "bullet 2", "... up to 6"],
+  "llm_insights": ["deeper insight 1", "deeper insight 2", "... up to 4"],
+  "risk_factors": ["risk 1", "risk 2"],
+  "competitive_moat": "what protects incumbents or what gap exists"
+}
+"""
+
+
+def _heuristic_analysis(product_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Rule-based analysis (no API key needed)."""
+    title = product_data.get("title", "")
+    price = product_data.get("current_price", 0) or 0
+    bsr = product_data.get("current_bsr", 0) or 0
+    rating = product_data.get("current_rating", 0) or 0
+    reviews = product_data.get("current_review_count", 0) or 0
+    monthly_sales = product_data.get("sales_estimate_monthly", 0) or 0
+    revenue = product_data.get("revenue_estimate_monthly", 0) or 0
+    score = product_data.get("opportunity_score", 0) or 0
+    category = product_data.get("category", "General") or "General"
+
+    if bsr <= 1000:
+        market_position = "Top Seller"
+        position_insight = "This product is in the top tier of Amazon sellers — extremely high demand but very competitive."
+    elif bsr <= 5000:
+        market_position = "Strong Performer"
+        position_insight = "Excellent sales velocity. High competition but proven market demand exists."
+    elif bsr <= 20000:
+        market_position = "Moderate Performer"
+        position_insight = "Solid product with consistent sales. Good entry point for new sellers."
+    elif bsr <= 100000:
+        market_position = "Niche Product"
+        position_insight = "Lower volume niche product. Less competition, but smaller market size."
+    else:
+        market_position = "Slow Mover"
+        position_insight = "Low sales velocity. May have seasonal demand or very specific audience."
+
+    if reviews >= 10000:
+        review_barrier = "Very High"
+        review_insight = f"With {reviews:,} reviews, breaking in is extremely difficult without significant investment."
+    elif reviews >= 1000:
+        review_barrier = "High"
+        review_insight = f"{reviews:,} reviews creates a significant trust barrier."
+    elif reviews >= 100:
+        review_barrier = "Medium"
+        review_insight = f"{reviews:,} reviews is manageable. Focus on getting first 50 reviews quickly."
+    else:
+        review_barrier = "Low"
+        review_insight = f"Only {reviews:,} reviews — great opportunity to compete with fresh listings."
+
+    if price >= 50:
+        price_insight = f"At ${price}, higher margins are possible. Customers expect premium quality."
+        pricing_strategy = "Premium positioning — invest in quality images and A+ content."
+    elif price >= 20:
+        price_insight = f"${price} is the sweet spot for Amazon FBA. Good margin potential."
+        pricing_strategy = "Competitive pricing — watch BSR changes when adjusting price by ±$2."
+    elif price >= 10:
+        price_insight = f"${price} is low margin territory after FBA fees."
+        pricing_strategy = "Consider bundling to improve margins."
+    else:
+        price_insight = f"At ${price}, FBA fees will consume most margin."
+        pricing_strategy = "High volume strategy required."
+
+    if rating >= 4.5:
+        rating_insight = f"{rating}★ rating is excellent. Match this quality to compete."
+        quality_bar = "Very High"
+    elif rating >= 4.0:
+        rating_insight = f"{rating}★ rating is good. Room to differentiate with better quality."
+        quality_bar = "High"
+    elif rating >= 3.5:
+        rating_insight = f"{rating}★ suggests customer dissatisfaction. Opportunity to do it better."
+        quality_bar = "Medium — Opportunity to differentiate"
+    else:
+        rating_insight = f"{rating}★ rating is poor. Strong opportunity if you solve core issues."
+        quality_bar = "Low — Big opportunity"
+
+    if score >= 70:
+        overall = "Strong Buy Signal"
+        summary = f"Promising opportunity in {category}. Strong sales velocity with manageable competition."
+        action = "Move forward with supplier sourcing. Test with a small initial order."
+    elif score >= 50:
+        overall = "Proceed with Caution"
+        summary = f"Moderate opportunity in {category}. Profitability possible but requires careful execution."
+        action = "Deep dive into top competitors before investing."
+    elif score >= 30:
+        overall = "Challenging Market"
+        summary = f"Difficult entry in {category}. High competition or low demand."
+        action = "Look for a sub-niche with less competition."
+    else:
+        overall = "Not Recommended"
+        summary = f"Unfavorable metrics in {category} for new entrants."
+        action = "Pass on this product."
+
+    recommendations: List[str] = []
+    if reviews < 50:
+        recommendations.append("Low review count — easier to rank with a new listing")
+    if rating < 4.0:
+        recommendations.append("Low rating — differentiate with better product quality")
+    if bsr > 50000:
+        recommendations.append("High BSR — validate demand before large investment")
+    if price > 30:
+        recommendations.append("Good price point — FBA margins should be healthy")
+    if monthly_sales > 500:
+        recommendations.append("High sales volume — proven market demand")
+    if score >= 60:
+        recommendations.append("Good opportunity score — worth serious consideration")
+
+    return {
+        "overall_signal": overall,
+        "summary": summary,
+        "action": action,
+        "market_position": market_position,
+        "position_insight": position_insight,
+        "review_barrier": review_barrier,
+        "review_insight": review_insight,
+        "price_insight": price_insight,
+        "pricing_strategy": pricing_strategy,
+        "rating_insight": rating_insight,
+        "quality_bar": quality_bar,
+        "recommendations": recommendations,
+        "llm_insights": [],
+        "risk_factors": [],
+        "competitive_moat": "",
+        "metrics_summary": {
+            "monthly_revenue": f"${revenue:,.0f}" if revenue else "N/A",
+            "monthly_units": f"~{monthly_sales:,}" if monthly_sales else "N/A",
+            "opportunity_score": score,
+            "market_position": market_position,
+        },
+        "used_llm": False,
+        "provider": "heuristic",
+        "engine": "rule-based",
+    }
+
+
+def generate_ai_analysis(product_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Generate AI analysis — LLM when API key configured, else heuristics."""
+    base = _heuristic_analysis(product_data)
+
+    if not is_llm_available():
+        return base
+
+    import json
+
+    user_prompt = (
+        f"Analyze this Amazon product for an FBA seller.\n\n"
+        f"PRODUCT DATA:\n{json.dumps(product_data, default=str)}\n\n"
+        f"Return JSON matching this schema:\n{AI_ANALYSIS_SCHEMA}"
+    )
+
+    llm_data, provider = generate_json(AI_ANALYSIS_SYSTEM, user_prompt)
+    if not llm_data:
+        return base
+
+    merged = {**base, **{k: v for k, v in llm_data.items() if v is not None}}
+    merged["used_llm"] = True
+    merged["provider"] = provider or get_active_provider() or "llm"
+    merged["engine"] = "llm"
+    merged["metrics_summary"] = base["metrics_summary"]
+    if not merged.get("recommendations"):
+        merged["recommendations"] = base["recommendations"]
+    return merged

app/services/analytics/amazon_fees.py

@@ -1,227 +1,227 @@
-"""Amazon US marketplace fee formulas (Seller Central Revenue Calculator aligned).
-
-Sources: Amazon Seller Central fee schedule (FBA fulfillment, referral, storage,
-inbound placement). Rates reflect 2024–2025 US standard-size tiers.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, Literal, Optional, Tuple
-
-Season = Literal["standard", "peak"]
-
-# Referral fee % by category keyword (Amazon US published rates)
-REFERRAL_RATES: Dict[str, float] = {
-    "amazon device": 0.45,
-    "apparel": 0.17,
-    "clothing": 0.17,
-    "shoe": 0.15,
-    "jewelry": 0.20,
-    "electronics": 0.08,
-    "computer": 0.08,
-    "camera": 0.08,
-    "beauty": 0.08,
-    "personal care": 0.08,
-    "health": 0.08,
-    "grocery": 0.08,
-    "baby": 0.08,
-    "book": 0.15,
-    "music": 0.15,
-    "video": 0.15,
-    "software": 0.15,
-    "video game": 0.15,
-    "game console": 0.08,
-    "toy": 0.15,
-    "home": 0.15,
-    "kitchen": 0.15,
-    "garden": 0.15,
-    "tool": 0.15,
-    "sport": 0.15,
-    "outdoor": 0.15,
-    "pet": 0.15,
-    "office": 0.15,
-    "industrial": 0.12,
-    "automotive": 0.12,
-    "default": 0.15,
-}
-
-REFERRAL_MIN = 0.30
-
-# FBA US fulfillment — standard-size non-apparel (2024 non-peak, excl. apparel)
-# Weight in oz → fee USD (small standard ≤16 oz, large standard ≤20 lb)
-SMALL_STANDARD_OZ: Tuple[Tuple[float, float], ...] = (
-    (2, 3.06),
-    (4, 3.15),
-    (6, 3.24),
-    (8, 3.33),
-    (10, 3.43),
-    (12, 3.53),
-    (14, 3.60),
-    (16, 3.65),
-)
-
-LARGE_STANDARD_LBS: Tuple[Tuple[float, float], ...] = (
-    (0.25, 3.86),
-    (0.5, 4.08),
-    (0.75, 4.24),
-    (1.0, 4.75),
-    (1.25, 5.19),
-    (1.5, 5.40),
-    (1.75, 5.69),
-    (2.0, 5.87),
-    (2.25, 6.08),
-    (2.5, 6.29),
-    (2.75, 6.48),
-    (3.0, 6.85),
-    (20.0, 9.73),
-)
-
-# Storage $/cu ft per month (standard-size)
-STORAGE_RATE_CUFT: Dict[Season, float] = {
-    "standard": 0.87,  # Jan–Sep
-    "peak": 2.40,      # Oct–Dec
-}
-
-# Default unit volume when dimensions unknown (typical small standard ~0.05 cu ft)
-DEFAULT_CU_FT_PER_UNIT = 0.05
-
-# Inbound placement service fee per unit (US, typical distributed inventory)
-INBOUND_PLACEMENT_DEFAULT = 0.56
-
-INBOUND_BY_REGION = {
-    "west": 0.56,
-    "central": 0.48,
-    "east": 0.52,
-}
-
-REMOVAL_FEE_PER_UNIT = 3.95
-DISPOSAL_FEE_PER_UNIT = 3.95
-
-
-def calculate_removal_disposal_cost(
-    removal_units: int = 0,
-    disposal_units: int = 0,
-    monthly_units_sold: float = 1.0,
-) -> Dict:
-    total = round(removal_units * REMOVAL_FEE_PER_UNIT + disposal_units * DISPOSAL_FEE_PER_UNIT, 2)
-    per_unit = round(total / max(monthly_units_sold, 1), 2) if total else 0.0
-    return {
-        "removal_fee_per_unit": REMOVAL_FEE_PER_UNIT,
-        "disposal_fee_per_unit": DISPOSAL_FEE_PER_UNIT,
-        "removal_units": removal_units,
-        "disposal_units": disposal_units,
-        "total_removal_disposal_fee": total,
-        "removal_disposal_cost_per_unit_sold": per_unit,
-    }
-
-
-@dataclass
-class ProductDimensions:
-    weight_lbs: float = 1.0
-    length_in: float = 10.0
-    width_in: float = 8.0
-    height_in: float = 2.0
-
-    @property
-    def weight_oz(self) -> float:
-        return self.weight_lbs * 16
-
-    @property
-    def cubic_feet(self) -> float:
-        return max((self.length_in * self.width_in * self.height_in) / 1728, 0.001)
-
-
-def resolve_referral_rate(category: str) -> Tuple[float, str]:
-    cat = (category or "").lower()
-    for key, rate in REFERRAL_RATES.items():
-        if key != "default" and key in cat:
-            return rate, key
-    return REFERRAL_RATES["default"], "default"
-
-
-def calculate_referral_fee(price: float, category: str = "default") -> Dict:
-    rate, matched = resolve_referral_rate(category)
-    fee = round(max(price * rate, REFERRAL_MIN), 2)
-    return {
-        "referral_fee": fee,
-        "referral_rate_percent": round(rate * 100, 1),
-        "referral_category": matched,
-        "fixed_closing_fee": 0.0,
-        "variable_closing_fee": 0.0,
-        "digital_services_fee": 0.0,
-    }
-
-
-def calculate_fba_fulfillment_fee(weight_lbs: float) -> Dict:
-    """Return FBA pick-pack-ship fee from weight tier."""
-    weight_oz = weight_lbs * 16
-    fee = 9.73
-    tier = "large_standard"
-
-    if weight_oz <= 16:
-        tier = "small_standard"
-        for max_oz, tier_fee in SMALL_STANDARD_OZ:
-            if weight_oz <= max_oz:
-                fee = tier_fee
-                break
-    else:
-        for max_lbs, tier_fee in LARGE_STANDARD_LBS:
-            if weight_lbs <= max_lbs:
-                fee = tier_fee
-                break
-
-    return {
-        "fba_fulfillment_fee": round(fee, 2),
-        "fulfillment_tier": tier,
-        "weight_lbs": round(weight_lbs, 3),
-        "weight_oz": round(weight_oz, 1),
-    }
-
-
-def calculate_storage_fee_per_unit(
-    dims: ProductDimensions,
-    season: Season = "standard",
-    avg_inventory_units: float = 1.0,
-    monthly_units_sold: float = 1.0,
-) -> Dict:
-    monthly_per_cuft = STORAGE_RATE_CUFT[season]
-    monthly_per_unit = round(dims.cubic_feet * monthly_per_cuft, 4)
-    if monthly_units_sold <= 0:
-        per_unit_sold = 0.0
-    else:
-        per_unit_sold = round((monthly_per_unit * max(avg_inventory_units, 0)) / monthly_units_sold, 2)
-    return {
-        "season": season,
-        "cubic_feet_per_unit": round(dims.cubic_feet, 4),
-        "monthly_storage_rate_per_cuft": monthly_per_cuft,
-        "monthly_storage_cost_per_unit": monthly_per_unit,
-        "avg_inventory_units": avg_inventory_units,
-        "monthly_units_sold": monthly_units_sold,
-        "storage_cost_per_unit_sold": per_unit_sold,
-    }
-
-
-def calculate_inbound_fees(
-    region: str = "west",
-    shipping_cost_per_shipment: float = 0.0,
-    units_per_shipment: int = 1,
-) -> Dict:
-    region_key = (region or "west").lower()
-    placement = INBOUND_BY_REGION.get(region_key, INBOUND_PLACEMENT_DEFAULT)
-    shipping_per_unit = round(shipping_cost_per_shipment / max(units_per_shipment, 1), 2)
-    total = round(placement + shipping_per_unit, 2)
-    return {
-        "inbound_region": region_key,
-        "inbound_placement_fee_per_unit": placement,
-        "shipping_cost_per_unit": shipping_per_unit,
-        "total_inbound_cost_per_unit": total,
-    }
-
-
-def estimate_dimensions_from_weight(weight_lbs: float) -> ProductDimensions:
-    """Estimate package size from weight when scrape has no dimensions."""
-    if weight_lbs <= 1:
-        return ProductDimensions(weight_lbs=weight_lbs, length_in=10, width_in=8, height_in=2)
-    if weight_lbs <= 3:
-        return ProductDimensions(weight_lbs=weight_lbs, length_in=14, width_in=10, height_in=4)
-    return ProductDimensions(weight_lbs=weight_lbs, length_in=18, width_in=12, height_in=6)
+"""Amazon US marketplace fee formulas (Seller Central Revenue Calculator aligned).
+
+Sources: Amazon Seller Central fee schedule (FBA fulfillment, referral, storage,
+inbound placement). Rates reflect 2024–2025 US standard-size tiers.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Literal, Optional, Tuple
+
+Season = Literal["standard", "peak"]
+
+# Referral fee % by category keyword (Amazon US published rates)
+REFERRAL_RATES: Dict[str, float] = {
+    "amazon device": 0.45,
+    "apparel": 0.17,
+    "clothing": 0.17,
+    "shoe": 0.15,
+    "jewelry": 0.20,
+    "electronics": 0.08,
+    "computer": 0.08,
+    "camera": 0.08,
+    "beauty": 0.08,
+    "personal care": 0.08,
+    "health": 0.08,
+    "grocery": 0.08,
+    "baby": 0.08,
+    "book": 0.15,
+    "music": 0.15,
+    "video": 0.15,
+    "software": 0.15,
+    "video game": 0.15,
+    "game console": 0.08,
+    "toy": 0.15,
+    "home": 0.15,
+    "kitchen": 0.15,
+    "garden": 0.15,
+    "tool": 0.15,
+    "sport": 0.15,
+    "outdoor": 0.15,
+    "pet": 0.15,
+    "office": 0.15,
+    "industrial": 0.12,
+    "automotive": 0.12,
+    "default": 0.15,
+}
+
+REFERRAL_MIN = 0.30
+
+# FBA US fulfillment — standard-size non-apparel (2024 non-peak, excl. apparel)
+# Weight in oz → fee USD (small standard ≤16 oz, large standard ≤20 lb)
+SMALL_STANDARD_OZ: Tuple[Tuple[float, float], ...] = (
+    (2, 3.06),
+    (4, 3.15),
+    (6, 3.24),
+    (8, 3.33),
+    (10, 3.43),
+    (12, 3.53),
+    (14, 3.60),
+    (16, 3.65),
+)
+
+LARGE_STANDARD_LBS: Tuple[Tuple[float, float], ...] = (
+    (0.25, 3.86),
+    (0.5, 4.08),
+    (0.75, 4.24),
+    (1.0, 4.75),
+    (1.25, 5.19),
+    (1.5, 5.40),
+    (1.75, 5.69),
+    (2.0, 5.87),
+    (2.25, 6.08),
+    (2.5, 6.29),
+    (2.75, 6.48),
+    (3.0, 6.85),
+    (20.0, 9.73),
+)
+
+# Storage $/cu ft per month (standard-size)
+STORAGE_RATE_CUFT: Dict[Season, float] = {
+    "standard": 0.87,  # Jan–Sep
+    "peak": 2.40,      # Oct–Dec
+}
+
+# Default unit volume when dimensions unknown (typical small standard ~0.05 cu ft)
+DEFAULT_CU_FT_PER_UNIT = 0.05
+
+# Inbound placement service fee per unit (US, typical distributed inventory)
+INBOUND_PLACEMENT_DEFAULT = 0.56
+
+INBOUND_BY_REGION = {
+    "west": 0.56,
+    "central": 0.48,
+    "east": 0.52,
+}
+
+REMOVAL_FEE_PER_UNIT = 3.95
+DISPOSAL_FEE_PER_UNIT = 3.95
+
+
+def calculate_removal_disposal_cost(
+    removal_units: int = 0,
+    disposal_units: int = 0,
+    monthly_units_sold: float = 1.0,
+) -> Dict:
+    total = round(removal_units * REMOVAL_FEE_PER_UNIT + disposal_units * DISPOSAL_FEE_PER_UNIT, 2)
+    per_unit = round(total / max(monthly_units_sold, 1), 2) if total else 0.0
+    return {
+        "removal_fee_per_unit": REMOVAL_FEE_PER_UNIT,
+        "disposal_fee_per_unit": DISPOSAL_FEE_PER_UNIT,
+        "removal_units": removal_units,
+        "disposal_units": disposal_units,
+        "total_removal_disposal_fee": total,
+        "removal_disposal_cost_per_unit_sold": per_unit,
+    }
+
+
+@dataclass
+class ProductDimensions:
+    weight_lbs: float = 1.0
+    length_in: float = 10.0
+    width_in: float = 8.0
+    height_in: float = 2.0
+
+    @property
+    def weight_oz(self) -> float:
+        return self.weight_lbs * 16
+
+    @property
+    def cubic_feet(self) -> float:
+        return max((self.length_in * self.width_in * self.height_in) / 1728, 0.001)
+
+
+def resolve_referral_rate(category: str) -> Tuple[float, str]:
+    cat = (category or "").lower()
+    for key, rate in REFERRAL_RATES.items():
+        if key != "default" and key in cat:
+            return rate, key
+    return REFERRAL_RATES["default"], "default"
+
+
+def calculate_referral_fee(price: float, category: str = "default") -> Dict:
+    rate, matched = resolve_referral_rate(category)
+    fee = round(max(price * rate, REFERRAL_MIN), 2)
+    return {
+        "referral_fee": fee,
+        "referral_rate_percent": round(rate * 100, 1),
+        "referral_category": matched,
+        "fixed_closing_fee": 0.0,
+        "variable_closing_fee": 0.0,
+        "digital_services_fee": 0.0,
+    }
+
+
+def calculate_fba_fulfillment_fee(weight_lbs: float) -> Dict:
+    """Return FBA pick-pack-ship fee from weight tier."""
+    weight_oz = weight_lbs * 16
+    fee = 9.73
+    tier = "large_standard"
+
+    if weight_oz <= 16:
+        tier = "small_standard"
+        for max_oz, tier_fee in SMALL_STANDARD_OZ:
+            if weight_oz <= max_oz:
+                fee = tier_fee
+                break
+    else:
+        for max_lbs, tier_fee in LARGE_STANDARD_LBS:
+            if weight_lbs <= max_lbs:
+                fee = tier_fee
+                break
+
+    return {
+        "fba_fulfillment_fee": round(fee, 2),
+        "fulfillment_tier": tier,
+        "weight_lbs": round(weight_lbs, 3),
+        "weight_oz": round(weight_oz, 1),
+    }
+
+
+def calculate_storage_fee_per_unit(
+    dims: ProductDimensions,
+    season: Season = "standard",
+    avg_inventory_units: float = 1.0,
+    monthly_units_sold: float = 1.0,
+) -> Dict:
+    monthly_per_cuft = STORAGE_RATE_CUFT[season]
+    monthly_per_unit = round(dims.cubic_feet * monthly_per_cuft, 4)
+    if monthly_units_sold <= 0:
+        per_unit_sold = 0.0
+    else:
+        per_unit_sold = round((monthly_per_unit * max(avg_inventory_units, 0)) / monthly_units_sold, 2)
+    return {
+        "season": season,
+        "cubic_feet_per_unit": round(dims.cubic_feet, 4),
+        "monthly_storage_rate_per_cuft": monthly_per_cuft,
+        "monthly_storage_cost_per_unit": monthly_per_unit,
+        "avg_inventory_units": avg_inventory_units,
+        "monthly_units_sold": monthly_units_sold,
+        "storage_cost_per_unit_sold": per_unit_sold,
+    }
+
+
+def calculate_inbound_fees(
+    region: str = "west",
+    shipping_cost_per_shipment: float = 0.0,
+    units_per_shipment: int = 1,
+) -> Dict:
+    region_key = (region or "west").lower()
+    placement = INBOUND_BY_REGION.get(region_key, INBOUND_PLACEMENT_DEFAULT)
+    shipping_per_unit = round(shipping_cost_per_shipment / max(units_per_shipment, 1), 2)
+    total = round(placement + shipping_per_unit, 2)
+    return {
+        "inbound_region": region_key,
+        "inbound_placement_fee_per_unit": placement,
+        "shipping_cost_per_unit": shipping_per_unit,
+        "total_inbound_cost_per_unit": total,
+    }
+
+
+def estimate_dimensions_from_weight(weight_lbs: float) -> ProductDimensions:
+    """Estimate package size from weight when scrape has no dimensions."""
+    if weight_lbs <= 1:
+        return ProductDimensions(weight_lbs=weight_lbs, length_in=10, width_in=8, height_in=2)
+    if weight_lbs <= 3:
+        return ProductDimensions(weight_lbs=weight_lbs, length_in=14, width_in=10, height_in=4)
+    return ProductDimensions(weight_lbs=weight_lbs, length_in=18, width_in=12, height_in=6)

app/services/analytics/buy_box_history.py

@@ -1,563 +1,563 @@
-"""Persist and analyze Buy Box winner history over time."""
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional
-
-from sqlalchemy.orm import Session
-
-from app.models.product import BuyBoxSnapshot
-from app.services.analytics.buy_box_rotation import estimate_buy_box_rotation
-
-
-def _normalize_winner(name: Optional[str]) -> str:
-    return (name or "Unknown").strip() or "Unknown"
-
-
-def _fba_label(is_fba: Optional[bool]) -> str:
-    if is_fba is True:
-        return "FBA"
-    if is_fba is False:
-        return "FBM"
-    return "—"
-
-
-def _ensure_utc(dt: datetime) -> datetime:
-    if dt.tzinfo is None:
-        return dt.replace(tzinfo=timezone.utc)
-    return dt
-
-
-def record_buy_box_snapshot(db: Session, product_id: str, data: dict) -> Optional[BuyBoxSnapshot]:
-    """Store Buy Box state after a scrape (skip rapid duplicates)."""
-    has_buy_box = data.get("has_buy_box", True)
-    winner = _normalize_winner(data.get("buy_box_winner")) if has_buy_box else None
-    price = data.get("buy_box_price")
-    is_fba = data.get("buy_box_is_fba") if has_buy_box else None
-    is_amazon = bool(data.get("is_amazon_sold", False))
-    seller_count = data.get("seller_count")
-
-    last = (
-        db.query(BuyBoxSnapshot)
-        .filter(BuyBoxSnapshot.product_id == product_id)
-        .order_by(BuyBoxSnapshot.recorded_at.desc())
-        .first()
-    )
-    if last:
-        last_at = _ensure_utc(last.recorded_at)
-        age_min = (datetime.now(timezone.utc) - last_at).total_seconds() / 60
-        same_state = (
-            bool(last.has_buy_box) == bool(has_buy_box)
-            and _normalize_winner(last.winner) == winner
-            and float(last.price or 0) == float(price or 0)
-            and last.is_fba == is_fba
-        )
-        if same_state and age_min < 30:
-            return last
-
-    snapshot = BuyBoxSnapshot(
-        product_id=product_id,
-        winner=winner,
-        price=price,
-        is_fba=is_fba,
-        is_amazon=is_amazon,
-        seller_count=seller_count,
-        has_buy_box=has_buy_box,
-    )
-    db.add(snapshot)
-    return snapshot
-
-
-def get_buy_box_snapshots(
-    db: Session,
-    product_id: str,
-    days: int = 30,
-    limit: int = 500,
-) -> List[BuyBoxSnapshot]:
-    cutoff = datetime.now(timezone.utc) - timedelta(days=max(days, 1))
-    return (
-        db.query(BuyBoxSnapshot)
-        .filter(
-            BuyBoxSnapshot.product_id == product_id,
-            BuyBoxSnapshot.recorded_at >= cutoff,
-        )
-        .order_by(BuyBoxSnapshot.recorded_at.asc())
-        .limit(limit)
-        .all()
-    )
-
-
-def snapshots_to_dicts(snapshots: List[BuyBoxSnapshot]) -> List[dict]:
-    return [
-        {
-            "winner": s.winner,
-            "price": float(s.price) if s.price is not None else None,
-            "is_fba": s.is_fba,
-            "is_amazon": bool(s.is_amazon),
-            "seller_count": s.seller_count,
-            "has_buy_box": bool(s.has_buy_box),
-            "recorded_at": _ensure_utc(s.recorded_at).isoformat(),
-        }
-        for s in snapshots
-    ]
-
-
-def _last_won_from_snapshots(seller: str, snapshots: List[BuyBoxSnapshot], current_winner: Optional[str]) -> str:
-    if current_winner and _normalize_winner(current_winner) == _normalize_winner(seller):
-        return "Current"
-    for snap in reversed(snapshots):
-        if snap.has_buy_box and _normalize_winner(snap.winner) == _normalize_winner(seller):
-            days_ago = (datetime.now(timezone.utc) - _ensure_utc(snap.recorded_at)).days
-            if days_ago <= 1:
-                return "Today"
-            if days_ago <= 3:
-                return "1–3 days ago"
-            if days_ago <= 7:
-                return "4–7 days ago"
-            if days_ago <= 14:
-                return "1–2 weeks ago"
-            return f"{days_ago} days ago"
-    return "2+ weeks ago"
-
-
-def rotation_from_snapshots(
-    snapshots: List[BuyBoxSnapshot],
-    range_days: int = 30,
-    fallback_data: Optional[dict] = None,
-) -> Dict[str, Any]:
-    """Compute seller Buy Box % from time-weighted snapshot history."""
-    active = [s for s in snapshots if s.has_buy_box and s.winner]
-    if len(active) < 2:
-        if fallback_data:
-            est = estimate_buy_box_rotation(fallback_data)
-            est["source"] = "estimated"
-            est["snapshot_count"] = len(snapshots)
-            return est
-        return {
-            "sellers": [],
-            "range_days": range_days,
-            "eligible_fba": 0,
-            "eligible_fbm": 0,
-            "total_sellers": 0,
-            "source": "insufficient_data",
-            "snapshot_count": len(snapshots),
-            "disclaimer": "Refresh this product a few times to build Buy Box history.",
-        }
-
-    now = datetime.now(timezone.utc)
-    cutoff = now - timedelta(days=range_days)
-    segments: List[tuple] = []
-
-    for i, snap in enumerate(active):
-        start = _ensure_utc(snap.recorded_at)
-        if start < cutoff:
-            start = cutoff
-        if i + 1 < len(active):
-            end = _ensure_utc(active[i + 1].recorded_at)
-        else:
-            end = now
-        if end <= start:
-            continue
-        if end < cutoff:
-            continue
-        duration_hours = (end - start).total_seconds() / 3600
-        if duration_hours <= 0:
-            continue
-        segments.append(
-            (
-                _normalize_winner(snap.winner),
-                duration_hours,
-                snap.is_fba,
-                float(snap.price) if snap.price is not None else None,
-                snap.is_amazon,
-            )
-        )
-
-    if not segments:
-        if fallback_data:
-            est = estimate_buy_box_rotation(fallback_data)
-            est["source"] = "estimated"
-            est["snapshot_count"] = len(snapshots)
-            return est
-        return {"sellers": [], "range_days": range_days, "source": "insufficient_data", "snapshot_count": len(snapshots)}
-
-    totals: Dict[str, dict] = {}
-    for seller, hours, is_fba, price, is_amazon in segments:
-        entry = totals.setdefault(
-            seller,
-            {"hours": 0.0, "prices": [], "is_fba": is_fba, "is_amazon": is_amazon},
-        )
-        entry["hours"] += hours
-        if price is not None:
-            entry["prices"].append(price)
-        if is_fba is not None:
-            entry["is_fba"] = is_fba
-
-    total_hours = sum(v["hours"] for v in totals.values()) or 1.0
-    current_winner = active[-1].winner if active else None
-
-    sellers = []
-    for seller, meta in totals.items():
-        pct = round(meta["hours"] / total_hours * 100, 1)
-        avg_price = round(sum(meta["prices"]) / len(meta["prices"]), 2) if meta["prices"] else None
-        sellers.append(
-            {
-                "seller": seller,
-                "win_percent": pct,
-                "avg_price": avg_price,
-                "is_fba": meta["is_fba"],
-                "fulfillment": _fba_label(meta["is_fba"]),
-                "rating": "98%" if meta.get("is_amazon") else "95%",
-                "last_won": _last_won_from_snapshots(seller, active, current_winner),
-                "stock": "In stock",
-            }
-        )
-
-    sellers.sort(key=lambda x: x["win_percent"], reverse=True)
-    drift = round(100.0 - sum(s["win_percent"] for s in sellers), 1)
-    if sellers and drift:
-        sellers[0]["win_percent"] = round(sellers[0]["win_percent"] + drift, 1)
-
-    fba_count = sum(1 for s in sellers if s.get("is_fba") is True)
-    fbm_count = sum(1 for s in sellers if s.get("is_fba") is False)
-    latest_seller_count = active[-1].seller_count or len(sellers)
-
-    return {
-        "sellers": sellers,
-        "range_days": range_days,
-        "eligible_fba": fba_count,
-        "eligible_fbm": fbm_count,
-        "total_sellers": latest_seller_count,
-        "source": "historical",
-        "snapshot_count": len(snapshots),
-        "disclaimer": (
-            f"Buy Box share from {len(snapshots)} recorded snapshots over {range_days} days. "
-            "Track and refresh products regularly for higher accuracy."
-        ),
-    }
-
-
-def build_buy_box_timeline(snapshots: List[BuyBoxSnapshot], range_days: int = 30) -> List[dict]:
-    if not snapshots:
-        return []
-
-    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
-    by_day: Dict[str, Dict[str, float]] = {}
-
-    ordered = sorted(snapshots, key=lambda s: _ensure_utc(s.recorded_at))
-    now = datetime.now(timezone.utc)
-
-    for i, snap in enumerate(ordered):
-        if not snap.has_buy_box or not snap.winner:
-            continue
-        start = _ensure_utc(snap.recorded_at)
-        if start < cutoff:
-            start = cutoff
-        end = _ensure_utc(ordered[i + 1].recorded_at) if i + 1 < len(ordered) else now
-        if end <= start:
-            continue
-
-        cursor = start
-        while cursor < end:
-            day_key = cursor.strftime("%Y-%m-%d")
-            day_end = (cursor + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
-            if day_end.tzinfo is None:
-                day_end = day_end.replace(tzinfo=timezone.utc)
-            segment_end = min(end, day_end)
-            hours = max((segment_end - cursor).total_seconds() / 3600, 0)
-            if hours > 0:
-                winner = _normalize_winner(snap.winner)
-                by_day.setdefault(day_key, {})
-                by_day[day_key][winner] = by_day[day_key].get(winner, 0) + hours
-            cursor = segment_end
-
-    timeline = []
-    for day in sorted(by_day.keys()):
-        winners = by_day[day]
-        dominant = max(winners, key=winners.get)
-        total = sum(winners.values()) or 1
-        timeline.append(
-            {
-                "date": day,
-                "dominant_seller": dominant,
-                "dominant_percent": round(winners[dominant] / total * 100, 1),
-                "sellers_active": len(winners),
-            }
-        )
-    return timeline
-
-
-def build_buy_box_price_series(snapshots: List[BuyBoxSnapshot], range_days: int = 90) -> List[dict]:
-    """Buy Box price + winner at each snapshot for line/scatter charts."""
-    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
-    series = []
-    for s in snapshots:
-        if not s.has_buy_box:
-            continue
-        at = _ensure_utc(s.recorded_at)
-        if at < cutoff:
-            continue
-        series.append(
-            {
-                "recorded_at": at.isoformat(),
-                "date": at.strftime("%Y-%m-%d"),
-                "buy_box_price": float(s.price) if s.price is not None else None,
-                "winner": s.winner,
-                "seller_count": s.seller_count,
-                "is_fba": s.is_fba,
-            }
-        )
-    return series
-
-
-def build_seller_count_series(snapshots: List[BuyBoxSnapshot], range_days: int = 90) -> List[dict]:
-    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
-    series = []
-    for s in snapshots:
-        at = _ensure_utc(s.recorded_at)
-        if at < cutoff:
-            continue
-        series.append(
-            {
-                "recorded_at": at.isoformat(),
-                "date": at.strftime("%Y-%m-%d %H:%M"),
-                "seller_count": s.seller_count or 1,
-                "has_buy_box": bool(s.has_buy_box),
-            }
-        )
-    return series
-
-
-def build_seller_rotation_series(snapshots: List[BuyBoxSnapshot], range_days: int = 30, top_n: int = 5) -> List[dict]:
-    """
-    Weekly stacked Buy Box share % per seller (for area/bar history chart).
-    """
-    active = [s for s in snapshots if s.has_buy_box and s.winner]
-    if len(active) < 2:
-        return []
-
-    now = datetime.now(timezone.utc)
-    cutoff = now - timedelta(days=range_days)
-    weekly: Dict[str, Dict[str, float]] = {}
-
-    for i, snap in enumerate(active):
-        start = _ensure_utc(snap.recorded_at)
-        if start < cutoff:
-            start = cutoff
-        end = _ensure_utc(active[i + 1].recorded_at) if i + 1 < len(active) else now
-        if end <= start:
-            continue
-        week_key = start.strftime("%Y-W%W")
-        hours = (end - start).total_seconds() / 3600
-        seller = _normalize_winner(snap.winner)
-        weekly.setdefault(week_key, {})
-        weekly[week_key][seller] = weekly[week_key].get(seller, 0) + hours
-
-    all_sellers: Dict[str, float] = {}
-    for w in weekly.values():
-        for seller, h in w.items():
-            all_sellers[seller] = all_sellers.get(seller, 0) + h
-    top_sellers = [s for s, _ in sorted(all_sellers.items(), key=lambda x: x[1], reverse=True)[:top_n]]
-
-    result = []
-    for week in sorted(weekly.keys()):
-        winners = weekly[week]
-        total = sum(winners.values()) or 1
-        row: Dict[str, Any] = {"week": week}
-        for seller in top_sellers:
-            row[seller] = round(winners.get(seller, 0) / total * 100, 1)
-        row["other"] = round(
-            sum(v for s, v in winners.items() if s not in top_sellers) / total * 100, 1
-        )
-        result.append(row)
-    return result
-
-
-def build_market_history_summary(
-    snapshots: List[BuyBoxSnapshot],
-    price_history: List[dict],
-    range_days: int = 30,
-) -> dict:
-    """Human-readable summary of how much history exists."""
-    bb_prices = [float(s.price) for s in snapshots if s.price is not None]
-    hist_prices = [float(r["price"]) for r in price_history if r.get("price") is not None]
-    all_prices = bb_prices or hist_prices
-    return {
-        "range_days": range_days,
-        "buy_box_snapshots": len(snapshots),
-        "price_points": len(price_history),
-        "price_current": round(all_prices[-1], 2) if all_prices else None,
-        "price_avg": round(sum(all_prices) / len(all_prices), 2) if all_prices else None,
-        "price_min": round(min(all_prices), 2) if all_prices else None,
-        "price_max": round(max(all_prices), 2) if all_prices else None,
-        "first_snapshot": _ensure_utc(snapshots[0].recorded_at).isoformat() if snapshots else None,
-        "last_snapshot": _ensure_utc(snapshots[-1].recorded_at).isoformat() if snapshots else None,
-        "first_price_record": price_history[0]["recorded_at"] if price_history else None,
-        "last_price_record": price_history[-1]["recorded_at"] if price_history else None,
-        "buy_box_price_min": round(min(bb_prices), 2) if bb_prices else None,
-        "buy_box_price_max": round(max(bb_prices), 2) if bb_prices else None,
-        "ready_for_rotation_chart": len(snapshots) >= 2,
-        "ready_for_weekly_rotation": len(snapshots) >= 4,
-    }
-
-
-def build_monthly_aggregates(price_history: List[dict], field: str = "price") -> List[dict]:
-    """Average metric by calendar month (YYYY-MM)."""
-    buckets: Dict[str, List[float]] = {}
-    for row in price_history:
-        val = row.get(field)
-        ts = row.get("recorded_at") or ""
-        if val is None or not ts:
-            continue
-        month = ts[:7]
-        buckets.setdefault(month, []).append(float(val))
-    return [
-        {"period": m, "label": m, "avg": round(sum(v) / len(v), 2), "count": len(v)}
-        for m, v in sorted(buckets.items())
-    ]
-
-
-def build_yearly_aggregates(price_history: List[dict], field: str = "price") -> List[dict]:
-    buckets: Dict[str, List[float]] = {}
-    for row in price_history:
-        val = row.get(field)
-        ts = row.get("recorded_at") or ""
-        if val is None or not ts:
-            continue
-        year = ts[:4]
-        buckets.setdefault(year, []).append(float(val))
-    return [
-        {"period": y, "label": y, "avg": round(sum(v) / len(v), 2), "count": len(v)}
-        for y, v in sorted(buckets.items())
-    ]
-
-
-def build_keepa_style_series(
-    price_history: List[dict],
-    snapshots: List[BuyBoxSnapshot],
-    range_days: int = 365,
-) -> List[dict]:
-    """Combined Keepa-style row: price, BSR, seller count per date."""
-    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
-    bb_by_date: Dict[str, dict] = {}
-    for s in snapshots:
-        at = _ensure_utc(s.recorded_at)
-        if at < cutoff:
-            continue
-        d = at.strftime("%Y-%m-%d")
-        bb_by_date[d] = {
-            "buy_box_price": float(s.price) if s.price else None,
-            "seller_count": s.seller_count,
-            "winner": s.winner,
-        }
-    rows = []
-    for row in price_history:
-        ts = row.get("recorded_at") or ""
-        if not ts:
-            continue
-        try:
-            if datetime.fromisoformat(ts.replace("Z", "+00:00")) < cutoff:
-                continue
-        except Exception:
-            pass
-        d = ts[:10]
-        bb = bb_by_date.get(d, {})
-        rows.append(
-            {
-                "date": d,
-                "price": row.get("price"),
-                "bsr": row.get("bsr"),
-                "review_count": row.get("review_count"),
-                "buy_box_price": bb.get("buy_box_price"),
-                "seller_count": bb.get("seller_count"),
-                "buy_box_winner": bb.get("winner"),
-            }
-        )
-    return rows
-
-
-def build_historical_charts_payload(
-    snapshots: List[BuyBoxSnapshot],
-    price_history: List[dict],
-    category: str = "default",
-    range_days: int = 90,
-    product_cost: float = 0.0,
-    misc_cost: float = 0.0,
-    weight_lbs: float = 1.0,
-) -> dict:
-    from app.services.amazon.sales_estimator import estimate_monthly_sales
-    from app.services.analytics.profit_calculator import build_profit_history_series
-
-    revenue_series = []
-    for row in price_history:
-        bsr = row.get("bsr") or 0
-        price = row.get("price")
-        if not price:
-            continue
-        sales = estimate_monthly_sales(bsr, category)
-        units = sales.get("monthly_units") or 0
-        revenue_series.append(
-            {
-                "recorded_at": row.get("recorded_at"),
-                "date": (row.get("recorded_at") or "")[:10],
-                "price": price,
-                "bsr": bsr,
-                "review_count": row.get("review_count"),
-                "monthly_units_est": units,
-                "monthly_revenue_est": round(units * float(price), 2) if units else None,
-            }
-        )
-
-    rotation_series = build_seller_rotation_series(snapshots, range_days=min(range_days, 90))
-    top_sellers = []
-    if rotation_series:
-        keys = set()
-        for row in rotation_series:
-            keys.update(k for k in row.keys() if k not in ("week", "other"))
-        top_sellers = sorted(keys)
-
-    return {
-        "range_days": range_days,
-        "summary": build_market_history_summary(snapshots, price_history, range_days),
-        "buy_box_price_series": build_buy_box_price_series(snapshots, range_days),
-        "seller_count_series": build_seller_count_series(snapshots, range_days),
-        "buy_box_timeline": build_buy_box_timeline(snapshots, min(range_days, 365)),
-        "seller_rotation_weekly": rotation_series,
-        "seller_rotation_labels": top_sellers + (["other"] if rotation_series else []),
-        "revenue_estimate_series": revenue_series,
-        "profit_comparison_series": build_profit_history_series(
-            price_history, category, weight_lbs, product_cost, misc_cost
-        ),
-        "keepa_style_series": build_keepa_style_series(price_history, snapshots, range_days),
-        "price_monthly": build_monthly_aggregates(price_history, "price"),
-        "price_yearly": build_yearly_aggregates(price_history, "price"),
-        "bsr_monthly": build_monthly_aggregates(price_history, "bsr"),
-        "bsr_yearly": build_yearly_aggregates(price_history, "bsr"),
-        "range_options": [30, 90, 180, 365],
-        "how_it_works": [
-            "Track this ASIN — Rankora refreshes every 6 hours (or on manual Refresh).",
-            "Each refresh saves price/BSR to price_history and Buy Box winner to buy_box_snapshots.",
-            "Buy Box % (Keepa-style) = hours each seller held the box between snapshots.",
-            "Monthly/yearly charts aggregate your stored refresh data — not dummy estimates.",
-            "Profit history recalculates FBA vs FBM at each past price using Amazon US fee formulas.",
-        ],
-    }
-
-
-def build_buy_box_history_payload(
-    db: Session,
-    product_id: str,
-    range_days: int = 30,
-    fallback_data: Optional[dict] = None,
-) -> dict:
-    snapshots = get_buy_box_snapshots(db, product_id, days=range_days)
-    rotation = rotation_from_snapshots(snapshots, range_days=range_days, fallback_data=fallback_data)
-    price_hist = fallback_data.get("price_history") if fallback_data else []
-    return {
-        "range_days": range_days,
-        "snapshot_count": len(snapshots),
-        "snapshots": snapshots_to_dicts(snapshots),
-        "timeline": build_buy_box_timeline(snapshots, range_days=range_days),
-        "rotation": rotation,
-        "charts": build_historical_charts_payload(snapshots, price_hist or [], category=(fallback_data or {}).get("category", "default"), range_days=range_days),
-    }
+"""Persist and analyze Buy Box winner history over time."""
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional
+
+from sqlalchemy.orm import Session
+
+from app.models.product import BuyBoxSnapshot
+from app.services.analytics.buy_box_rotation import estimate_buy_box_rotation
+
+
+def _normalize_winner(name: Optional[str]) -> str:
+    return (name or "Unknown").strip() or "Unknown"
+
+
+def _fba_label(is_fba: Optional[bool]) -> str:
+    if is_fba is True:
+        return "FBA"
+    if is_fba is False:
+        return "FBM"
+    return "—"
+
+
+def _ensure_utc(dt: datetime) -> datetime:
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def record_buy_box_snapshot(db: Session, product_id: str, data: dict) -> Optional[BuyBoxSnapshot]:
+    """Store Buy Box state after a scrape (skip rapid duplicates)."""
+    has_buy_box = data.get("has_buy_box", True)
+    winner = _normalize_winner(data.get("buy_box_winner")) if has_buy_box else None
+    price = data.get("buy_box_price")
+    is_fba = data.get("buy_box_is_fba") if has_buy_box else None
+    is_amazon = bool(data.get("is_amazon_sold", False))
+    seller_count = data.get("seller_count")
+
+    last = (
+        db.query(BuyBoxSnapshot)
+        .filter(BuyBoxSnapshot.product_id == product_id)
+        .order_by(BuyBoxSnapshot.recorded_at.desc())
+        .first()
+    )
+    if last:
+        last_at = _ensure_utc(last.recorded_at)
+        age_min = (datetime.now(timezone.utc) - last_at).total_seconds() / 60
+        same_state = (
+            bool(last.has_buy_box) == bool(has_buy_box)
+            and _normalize_winner(last.winner) == winner
+            and float(last.price or 0) == float(price or 0)
+            and last.is_fba == is_fba
+        )
+        if same_state and age_min < 30:
+            return last
+
+    snapshot = BuyBoxSnapshot(
+        product_id=product_id,
+        winner=winner,
+        price=price,
+        is_fba=is_fba,
+        is_amazon=is_amazon,
+        seller_count=seller_count,
+        has_buy_box=has_buy_box,
+    )
+    db.add(snapshot)
+    return snapshot
+
+
+def get_buy_box_snapshots(
+    db: Session,
+    product_id: str,
+    days: int = 30,
+    limit: int = 500,
+) -> List[BuyBoxSnapshot]:
+    cutoff = datetime.now(timezone.utc) - timedelta(days=max(days, 1))
+    return (
+        db.query(BuyBoxSnapshot)
+        .filter(
+            BuyBoxSnapshot.product_id == product_id,
+            BuyBoxSnapshot.recorded_at >= cutoff,
+        )
+        .order_by(BuyBoxSnapshot.recorded_at.asc())
+        .limit(limit)
+        .all()
+    )
+
+
+def snapshots_to_dicts(snapshots: List[BuyBoxSnapshot]) -> List[dict]:
+    return [
+        {
+            "winner": s.winner,
+            "price": float(s.price) if s.price is not None else None,
+            "is_fba": s.is_fba,
+            "is_amazon": bool(s.is_amazon),
+            "seller_count": s.seller_count,
+            "has_buy_box": bool(s.has_buy_box),
+            "recorded_at": _ensure_utc(s.recorded_at).isoformat(),
+        }
+        for s in snapshots
+    ]
+
+
+def _last_won_from_snapshots(seller: str, snapshots: List[BuyBoxSnapshot], current_winner: Optional[str]) -> str:
+    if current_winner and _normalize_winner(current_winner) == _normalize_winner(seller):
+        return "Current"
+    for snap in reversed(snapshots):
+        if snap.has_buy_box and _normalize_winner(snap.winner) == _normalize_winner(seller):
+            days_ago = (datetime.now(timezone.utc) - _ensure_utc(snap.recorded_at)).days
+            if days_ago <= 1:
+                return "Today"
+            if days_ago <= 3:
+                return "1–3 days ago"
+            if days_ago <= 7:
+                return "4–7 days ago"
+            if days_ago <= 14:
+                return "1–2 weeks ago"
+            return f"{days_ago} days ago"
+    return "2+ weeks ago"
+
+
+def rotation_from_snapshots(
+    snapshots: List[BuyBoxSnapshot],
+    range_days: int = 30,
+    fallback_data: Optional[dict] = None,
+) -> Dict[str, Any]:
+    """Compute seller Buy Box % from time-weighted snapshot history."""
+    active = [s for s in snapshots if s.has_buy_box and s.winner]
+    if len(active) < 2:
+        if fallback_data:
+            est = estimate_buy_box_rotation(fallback_data)
+            est["source"] = "estimated"
+            est["snapshot_count"] = len(snapshots)
+            return est
+        return {
+            "sellers": [],
+            "range_days": range_days,
+            "eligible_fba": 0,
+            "eligible_fbm": 0,
+            "total_sellers": 0,
+            "source": "insufficient_data",
+            "snapshot_count": len(snapshots),
+            "disclaimer": "Refresh this product a few times to build Buy Box history.",
+        }
+
+    now = datetime.now(timezone.utc)
+    cutoff = now - timedelta(days=range_days)
+    segments: List[tuple] = []
+
+    for i, snap in enumerate(active):
+        start = _ensure_utc(snap.recorded_at)
+        if start < cutoff:
+            start = cutoff
+        if i + 1 < len(active):
+            end = _ensure_utc(active[i + 1].recorded_at)
+        else:
+            end = now
+        if end <= start:
+            continue
+        if end < cutoff:
+            continue
+        duration_hours = (end - start).total_seconds() / 3600
+        if duration_hours <= 0:
+            continue
+        segments.append(
+            (
+                _normalize_winner(snap.winner),
+                duration_hours,
+                snap.is_fba,
+                float(snap.price) if snap.price is not None else None,
+                snap.is_amazon,
+            )
+        )
+
+    if not segments:
+        if fallback_data:
+            est = estimate_buy_box_rotation(fallback_data)
+            est["source"] = "estimated"
+            est["snapshot_count"] = len(snapshots)
+            return est
+        return {"sellers": [], "range_days": range_days, "source": "insufficient_data", "snapshot_count": len(snapshots)}
+
+    totals: Dict[str, dict] = {}
+    for seller, hours, is_fba, price, is_amazon in segments:
+        entry = totals.setdefault(
+            seller,
+            {"hours": 0.0, "prices": [], "is_fba": is_fba, "is_amazon": is_amazon},
+        )
+        entry["hours"] += hours
+        if price is not None:
+            entry["prices"].append(price)
+        if is_fba is not None:
+            entry["is_fba"] = is_fba
+
+    total_hours = sum(v["hours"] for v in totals.values()) or 1.0
+    current_winner = active[-1].winner if active else None
+
+    sellers = []
+    for seller, meta in totals.items():
+        pct = round(meta["hours"] / total_hours * 100, 1)
+        avg_price = round(sum(meta["prices"]) / len(meta["prices"]), 2) if meta["prices"] else None
+        sellers.append(
+            {
+                "seller": seller,
+                "win_percent": pct,
+                "avg_price": avg_price,
+                "is_fba": meta["is_fba"],
+                "fulfillment": _fba_label(meta["is_fba"]),
+                "rating": "98%" if meta.get("is_amazon") else "95%",
+                "last_won": _last_won_from_snapshots(seller, active, current_winner),
+                "stock": "In stock",
+            }
+        )
+
+    sellers.sort(key=lambda x: x["win_percent"], reverse=True)
+    drift = round(100.0 - sum(s["win_percent"] for s in sellers), 1)
+    if sellers and drift:
+        sellers[0]["win_percent"] = round(sellers[0]["win_percent"] + drift, 1)
+
+    fba_count = sum(1 for s in sellers if s.get("is_fba") is True)
+    fbm_count = sum(1 for s in sellers if s.get("is_fba") is False)
+    latest_seller_count = active[-1].seller_count or len(sellers)
+
+    return {
+        "sellers": sellers,
+        "range_days": range_days,
+        "eligible_fba": fba_count,
+        "eligible_fbm": fbm_count,
+        "total_sellers": latest_seller_count,
+        "source": "historical",
+        "snapshot_count": len(snapshots),
+        "disclaimer": (
+            f"Buy Box share from {len(snapshots)} recorded snapshots over {range_days} days. "
+            "Track and refresh products regularly for higher accuracy."
+        ),
+    }
+
+
+def build_buy_box_timeline(snapshots: List[BuyBoxSnapshot], range_days: int = 30) -> List[dict]:
+    if not snapshots:
+        return []
+
+    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
+    by_day: Dict[str, Dict[str, float]] = {}
+
+    ordered = sorted(snapshots, key=lambda s: _ensure_utc(s.recorded_at))
+    now = datetime.now(timezone.utc)
+
+    for i, snap in enumerate(ordered):
+        if not snap.has_buy_box or not snap.winner:
+            continue
+        start = _ensure_utc(snap.recorded_at)
+        if start < cutoff:
+            start = cutoff
+        end = _ensure_utc(ordered[i + 1].recorded_at) if i + 1 < len(ordered) else now
+        if end <= start:
+            continue
+
+        cursor = start
+        while cursor < end:
+            day_key = cursor.strftime("%Y-%m-%d")
+            day_end = (cursor + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+            if day_end.tzinfo is None:
+                day_end = day_end.replace(tzinfo=timezone.utc)
+            segment_end = min(end, day_end)
+            hours = max((segment_end - cursor).total_seconds() / 3600, 0)
+            if hours > 0:
+                winner = _normalize_winner(snap.winner)
+                by_day.setdefault(day_key, {})
+                by_day[day_key][winner] = by_day[day_key].get(winner, 0) + hours
+            cursor = segment_end
+
+    timeline = []
+    for day in sorted(by_day.keys()):
+        winners = by_day[day]
+        dominant = max(winners, key=winners.get)
+        total = sum(winners.values()) or 1
+        timeline.append(
+            {
+                "date": day,
+                "dominant_seller": dominant,
+                "dominant_percent": round(winners[dominant] / total * 100, 1),
+                "sellers_active": len(winners),
+            }
+        )
+    return timeline
+
+
+def build_buy_box_price_series(snapshots: List[BuyBoxSnapshot], range_days: int = 90) -> List[dict]:
+    """Buy Box price + winner at each snapshot for line/scatter charts."""
+    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
+    series = []
+    for s in snapshots:
+        if not s.has_buy_box:
+            continue
+        at = _ensure_utc(s.recorded_at)
+        if at < cutoff:
+            continue
+        series.append(
+            {
+                "recorded_at": at.isoformat(),
+                "date": at.strftime("%Y-%m-%d"),
+                "buy_box_price": float(s.price) if s.price is not None else None,
+                "winner": s.winner,
+                "seller_count": s.seller_count,
+                "is_fba": s.is_fba,
+            }
+        )
+    return series
+
+
+def build_seller_count_series(snapshots: List[BuyBoxSnapshot], range_days: int = 90) -> List[dict]:
+    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
+    series = []
+    for s in snapshots:
+        at = _ensure_utc(s.recorded_at)
+        if at < cutoff:
+            continue
+        series.append(
+            {
+                "recorded_at": at.isoformat(),
+                "date": at.strftime("%Y-%m-%d %H:%M"),
+                "seller_count": s.seller_count or 1,
+                "has_buy_box": bool(s.has_buy_box),
+            }
+        )
+    return series
+
+
+def build_seller_rotation_series(snapshots: List[BuyBoxSnapshot], range_days: int = 30, top_n: int = 5) -> List[dict]:
+    """
+    Weekly stacked Buy Box share % per seller (for area/bar history chart).
+    """
+    active = [s for s in snapshots if s.has_buy_box and s.winner]
+    if len(active) < 2:
+        return []
+
+    now = datetime.now(timezone.utc)
+    cutoff = now - timedelta(days=range_days)
+    weekly: Dict[str, Dict[str, float]] = {}
+
+    for i, snap in enumerate(active):
+        start = _ensure_utc(snap.recorded_at)
+        if start < cutoff:
+            start = cutoff
+        end = _ensure_utc(active[i + 1].recorded_at) if i + 1 < len(active) else now
+        if end <= start:
+            continue
+        week_key = start.strftime("%Y-W%W")
+        hours = (end - start).total_seconds() / 3600
+        seller = _normalize_winner(snap.winner)
+        weekly.setdefault(week_key, {})
+        weekly[week_key][seller] = weekly[week_key].get(seller, 0) + hours
+
+    all_sellers: Dict[str, float] = {}
+    for w in weekly.values():
+        for seller, h in w.items():
+            all_sellers[seller] = all_sellers.get(seller, 0) + h
+    top_sellers = [s for s, _ in sorted(all_sellers.items(), key=lambda x: x[1], reverse=True)[:top_n]]
+
+    result = []
+    for week in sorted(weekly.keys()):
+        winners = weekly[week]
+        total = sum(winners.values()) or 1
+        row: Dict[str, Any] = {"week": week}
+        for seller in top_sellers:
+            row[seller] = round(winners.get(seller, 0) / total * 100, 1)
+        row["other"] = round(
+            sum(v for s, v in winners.items() if s not in top_sellers) / total * 100, 1
+        )
+        result.append(row)
+    return result
+
+
+def build_market_history_summary(
+    snapshots: List[BuyBoxSnapshot],
+    price_history: List[dict],
+    range_days: int = 30,
+) -> dict:
+    """Human-readable summary of how much history exists."""
+    bb_prices = [float(s.price) for s in snapshots if s.price is not None]
+    hist_prices = [float(r["price"]) for r in price_history if r.get("price") is not None]
+    all_prices = bb_prices or hist_prices
+    return {
+        "range_days": range_days,
+        "buy_box_snapshots": len(snapshots),
+        "price_points": len(price_history),
+        "price_current": round(all_prices[-1], 2) if all_prices else None,
+        "price_avg": round(sum(all_prices) / len(all_prices), 2) if all_prices else None,
+        "price_min": round(min(all_prices), 2) if all_prices else None,
+        "price_max": round(max(all_prices), 2) if all_prices else None,
+        "first_snapshot": _ensure_utc(snapshots[0].recorded_at).isoformat() if snapshots else None,
+        "last_snapshot": _ensure_utc(snapshots[-1].recorded_at).isoformat() if snapshots else None,
+        "first_price_record": price_history[0]["recorded_at"] if price_history else None,
+        "last_price_record": price_history[-1]["recorded_at"] if price_history else None,
+        "buy_box_price_min": round(min(bb_prices), 2) if bb_prices else None,
+        "buy_box_price_max": round(max(bb_prices), 2) if bb_prices else None,
+        "ready_for_rotation_chart": len(snapshots) >= 2,
+        "ready_for_weekly_rotation": len(snapshots) >= 4,
+    }
+
+
+def build_monthly_aggregates(price_history: List[dict], field: str = "price") -> List[dict]:
+    """Average metric by calendar month (YYYY-MM)."""
+    buckets: Dict[str, List[float]] = {}
+    for row in price_history:
+        val = row.get(field)
+        ts = row.get("recorded_at") or ""
+        if val is None or not ts:
+            continue
+        month = ts[:7]
+        buckets.setdefault(month, []).append(float(val))
+    return [
+        {"period": m, "label": m, "avg": round(sum(v) / len(v), 2), "count": len(v)}
+        for m, v in sorted(buckets.items())
+    ]
+
+
+def build_yearly_aggregates(price_history: List[dict], field: str = "price") -> List[dict]:
+    buckets: Dict[str, List[float]] = {}
+    for row in price_history:
+        val = row.get(field)
+        ts = row.get("recorded_at") or ""
+        if val is None or not ts:
+            continue
+        year = ts[:4]
+        buckets.setdefault(year, []).append(float(val))
+    return [
+        {"period": y, "label": y, "avg": round(sum(v) / len(v), 2), "count": len(v)}
+        for y, v in sorted(buckets.items())
+    ]
+
+
+def build_keepa_style_series(
+    price_history: List[dict],
+    snapshots: List[BuyBoxSnapshot],
+    range_days: int = 365,
+) -> List[dict]:
+    """Combined Keepa-style row: price, BSR, seller count per date."""
+    cutoff = datetime.now(timezone.utc) - timedelta(days=range_days)
+    bb_by_date: Dict[str, dict] = {}
+    for s in snapshots:
+        at = _ensure_utc(s.recorded_at)
+        if at < cutoff:
+            continue
+        d = at.strftime("%Y-%m-%d")
+        bb_by_date[d] = {
+            "buy_box_price": float(s.price) if s.price else None,
+            "seller_count": s.seller_count,
+            "winner": s.winner,
+        }
+    rows = []
+    for row in price_history:
+        ts = row.get("recorded_at") or ""
+        if not ts:
+            continue
+        try:
+            if datetime.fromisoformat(ts.replace("Z", "+00:00")) < cutoff:
+                continue
+        except Exception:
+            pass
+        d = ts[:10]
+        bb = bb_by_date.get(d, {})
+        rows.append(
+            {
+                "date": d,
+                "price": row.get("price"),
+                "bsr": row.get("bsr"),
+                "review_count": row.get("review_count"),
+                "buy_box_price": bb.get("buy_box_price"),
+                "seller_count": bb.get("seller_count"),
+                "buy_box_winner": bb.get("winner"),
+            }
+        )
+    return rows
+
+
+def build_historical_charts_payload(
+    snapshots: List[BuyBoxSnapshot],
+    price_history: List[dict],
+    category: str = "default",
+    range_days: int = 90,
+    product_cost: float = 0.0,
+    misc_cost: float = 0.0,
+    weight_lbs: float = 1.0,
+) -> dict:
+    from app.services.amazon.sales_estimator import estimate_monthly_sales
+    from app.services.analytics.profit_calculator import build_profit_history_series
+
+    revenue_series = []
+    for row in price_history:
+        bsr = row.get("bsr") or 0
+        price = row.get("price")
+        if not price:
+            continue
+        sales = estimate_monthly_sales(bsr, category)
+        units = sales.get("monthly_units") or 0
+        revenue_series.append(
+            {
+                "recorded_at": row.get("recorded_at"),
+                "date": (row.get("recorded_at") or "")[:10],
+                "price": price,
+                "bsr": bsr,
+                "review_count": row.get("review_count"),
+                "monthly_units_est": units,
+                "monthly_revenue_est": round(units * float(price), 2) if units else None,
+            }
+        )
+
+    rotation_series = build_seller_rotation_series(snapshots, range_days=min(range_days, 90))
+    top_sellers = []
+    if rotation_series:
+        keys = set()
+        for row in rotation_series:
+            keys.update(k for k in row.keys() if k not in ("week", "other"))
+        top_sellers = sorted(keys)
+
+    return {
+        "range_days": range_days,
+        "summary": build_market_history_summary(snapshots, price_history, range_days),
+        "buy_box_price_series": build_buy_box_price_series(snapshots, range_days),
+        "seller_count_series": build_seller_count_series(snapshots, range_days),
+        "buy_box_timeline": build_buy_box_timeline(snapshots, min(range_days, 365)),
+        "seller_rotation_weekly": rotation_series,
+        "seller_rotation_labels": top_sellers + (["other"] if rotation_series else []),
+        "revenue_estimate_series": revenue_series,
+        "profit_comparison_series": build_profit_history_series(
+            price_history, category, weight_lbs, product_cost, misc_cost
+        ),
+        "keepa_style_series": build_keepa_style_series(price_history, snapshots, range_days),
+        "price_monthly": build_monthly_aggregates(price_history, "price"),
+        "price_yearly": build_yearly_aggregates(price_history, "price"),
+        "bsr_monthly": build_monthly_aggregates(price_history, "bsr"),
+        "bsr_yearly": build_yearly_aggregates(price_history, "bsr"),
+        "range_options": [30, 90, 180, 365],
+        "how_it_works": [
+            "Track this ASIN — Rankora refreshes every 6 hours (or on manual Refresh).",
+            "Each refresh saves price/BSR to price_history and Buy Box winner to buy_box_snapshots.",
+            "Buy Box % (Keepa-style) = hours each seller held the box between snapshots.",
+            "Monthly/yearly charts aggregate your stored refresh data — not dummy estimates.",
+            "Profit history recalculates FBA vs FBM at each past price using Amazon US fee formulas.",
+        ],
+    }
+
+
+def build_buy_box_history_payload(
+    db: Session,
+    product_id: str,
+    range_days: int = 30,
+    fallback_data: Optional[dict] = None,
+) -> dict:
+    snapshots = get_buy_box_snapshots(db, product_id, days=range_days)
+    rotation = rotation_from_snapshots(snapshots, range_days=range_days, fallback_data=fallback_data)
+    price_hist = fallback_data.get("price_history") if fallback_data else []
+    return {
+        "range_days": range_days,
+        "snapshot_count": len(snapshots),
+        "snapshots": snapshots_to_dicts(snapshots),
+        "timeline": build_buy_box_timeline(snapshots, range_days=range_days),
+        "rotation": rotation,
+        "charts": build_historical_charts_payload(snapshots, price_hist or [], category=(fallback_data or {}).get("category", "default"), range_days=range_days),
+    }

app/services/analytics/buy_box_rotation.py

@@ -1,153 +1,153 @@
-"""Buy Box rotation from real scraped offers and historical snapshots only."""
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-
-def _fba_label(is_fba: Optional[bool]) -> str:
-    if is_fba is True:
-        return "FBA"
-    if is_fba is False:
-        return "FBM"
-    return "—"
-
-
-def estimate_buy_box_rotation(data: dict) -> Dict[str, Any]:
-    """
-    Build seller Buy Box share table from live offer data only.
-    No synthetic sellers — if Amazon does not expose offers, returns empty with guidance.
-    """
-    seller_count = max(int(data.get("seller_count") or 1), 1)
-    buy_box_price = float(data.get("buy_box_price") or data.get("price") or 0) or 0.0
-    winner = (data.get("buy_box_winner") or "Buy Box Winner").strip()
-    is_fba_winner = data.get("buy_box_is_fba")
-    is_amazon = bool(data.get("is_amazon_sold"))
-    other_sellers: List[dict] = list(data.get("other_sellers") or [])
-
-    offers: List[dict] = []
-
-    if data.get("has_buy_box", True):
-        offers.append(
-            {
-                "name": winner,
-                "is_fba": is_fba_winner if is_fba_winner is not None else True,
-                "price": buy_box_price,
-                "rating": "98%" if is_amazon else "95%",
-                "is_current_winner": True,
-            }
-        )
-
-    for s in other_sellers:
-        name = (s.get("name") or "").strip()
-        if not name or name.lower() == winner.lower():
-            continue
-        offers.append(
-            {
-                "name": name,
-                "is_fba": s.get("is_fba"),
-                "price": float(s.get("price") or buy_box_price) if (s.get("price") or buy_box_price) else None,
-                "rating": s.get("rating") or "90%",
-                "is_current_winner": False,
-            }
-        )
-
-    if len(offers) <= 1 and seller_count > 1:
-        return {
-            "sellers": [],
-            "range_days": 30,
-            "eligible_fba": data.get("fba_seller_count") or 0,
-            "eligible_fbm": data.get("fbm_seller_count") or 0,
-            "total_sellers": seller_count,
-            "source": "insufficient_offers",
-            "disclaimer": (
-                f"Amazon reports {seller_count} sellers but offer details were not available. "
-                "Refresh the product or track it to build Buy Box history from snapshots."
-            ),
-        }
-
-    if not offers:
-        return {
-            "sellers": [],
-            "range_days": 30,
-            "eligible_fba": 0,
-            "eligible_fbm": 0,
-            "total_sellers": seller_count,
-            "source": "no_data",
-            "disclaimer": "No Buy Box offer data available for this listing.",
-        }
-
-    # Weight by competitive strength: current winner, FBA, price proximity
-    weights: List[float] = []
-    for i, offer in enumerate(offers):
-        w = 1.0
-        if offer.get("is_current_winner"):
-            w *= 4.0
-        if offer.get("is_fba") is True:
-            w *= 2.2
-        elif offer.get("is_fba") is False:
-            w *= 0.65
-        if is_amazon and i == 0:
-            w *= 2.5
-        if buy_box_price and offer.get("price"):
-            gap = abs(offer["price"] - buy_box_price) / buy_box_price
-            if gap <= 0.02:
-                w *= 1.35
-            elif gap <= 0.08:
-                w *= 1.1
-            else:
-                w *= max(0.45, 1 - gap)
-        weights.append(w)
-
-    total_w = sum(weights) or 1.0
-    raw_pcts = [round(w / total_w * 100, 1) for w in weights]
-    drift = round(100.0 - sum(raw_pcts), 1)
-    if raw_pcts:
-        raw_pcts[0] = round(raw_pcts[0] + drift, 1)
-
-    rotation = []
-    for offer, pct in zip(offers, raw_pcts):
-        rotation.append(
-            {
-                "seller": offer["name"],
-                "win_percent": pct,
-                "avg_price": offer.get("price"),
-                "is_fba": offer.get("is_fba"),
-                "fulfillment": _fba_label(offer.get("is_fba")),
-                "rating": offer.get("rating"),
-                "last_won": "Current" if offer.get("is_current_winner") else _last_won_label(pct),
-                "stock": "In stock",
-            }
-        )
-
-    rotation.sort(key=lambda x: x["win_percent"], reverse=True)
-
-    fba_count = data.get("fba_seller_count")
-    fbm_count = data.get("fbm_seller_count")
-    if fba_count is None:
-        fba_count = sum(1 for o in offers if o.get("is_fba") is True)
-    if fbm_count is None:
-        fbm_count = sum(1 for o in offers if o.get("is_fba") is False)
-
-    offers_source = data.get("offers_source", "live")
-    return {
-        "sellers": rotation,
-        "range_days": 30,
-        "eligible_fba": fba_count,
-        "eligible_fbm": fbm_count,
-        "total_sellers": max(seller_count, len(offers)),
-        "source": "live_offers" if len(offers) > 1 else "estimated",
-        "disclaimer": (
-            f"Buy Box share from {len(offers)} live Amazon offers ({offers_source}). "
-            "Track and refresh for historical rotation accuracy."
-        ),
-    }
-
-
-def _last_won_label(win_percent: float) -> str:
-    if win_percent >= 25:
-        return "1–3 days ago"
-    if win_percent >= 10:
-        return "4–7 days ago"
-    if win_percent >= 5:
-        return "1–2 weeks ago"
-    return "2+ weeks ago"
+"""Buy Box rotation from real scraped offers and historical snapshots only."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+def _fba_label(is_fba: Optional[bool]) -> str:
+    if is_fba is True:
+        return "FBA"
+    if is_fba is False:
+        return "FBM"
+    return "—"
+
+
+def estimate_buy_box_rotation(data: dict) -> Dict[str, Any]:
+    """
+    Build seller Buy Box share table from live offer data only.
+    No synthetic sellers — if Amazon does not expose offers, returns empty with guidance.
+    """
+    seller_count = max(int(data.get("seller_count") or 1), 1)
+    buy_box_price = float(data.get("buy_box_price") or data.get("price") or 0) or 0.0
+    winner = (data.get("buy_box_winner") or "Buy Box Winner").strip()
+    is_fba_winner = data.get("buy_box_is_fba")
+    is_amazon = bool(data.get("is_amazon_sold"))
+    other_sellers: List[dict] = list(data.get("other_sellers") or [])
+
+    offers: List[dict] = []
+
+    if data.get("has_buy_box", True):
+        offers.append(
+            {
+                "name": winner,
+                "is_fba": is_fba_winner if is_fba_winner is not None else True,
+                "price": buy_box_price,
+                "rating": "98%" if is_amazon else "95%",
+                "is_current_winner": True,
+            }
+        )
+
+    for s in other_sellers:
+        name = (s.get("name") or "").strip()
+        if not name or name.lower() == winner.lower():
+            continue
+        offers.append(
+            {
+                "name": name,
+                "is_fba": s.get("is_fba"),
+                "price": float(s.get("price") or buy_box_price) if (s.get("price") or buy_box_price) else None,
+                "rating": s.get("rating") or "90%",
+                "is_current_winner": False,
+            }
+        )
+
+    if len(offers) <= 1 and seller_count > 1:
+        return {
+            "sellers": [],
+            "range_days": 30,
+            "eligible_fba": data.get("fba_seller_count") or 0,
+            "eligible_fbm": data.get("fbm_seller_count") or 0,
+            "total_sellers": seller_count,
+            "source": "insufficient_offers",
+            "disclaimer": (
+                f"Amazon reports {seller_count} sellers but offer details were not available. "
+                "Refresh the product or track it to build Buy Box history from snapshots."
+            ),
+        }
+
+    if not offers:
+        return {
+            "sellers": [],
+            "range_days": 30,
+            "eligible_fba": 0,
+            "eligible_fbm": 0,
+            "total_sellers": seller_count,
+            "source": "no_data",
+            "disclaimer": "No Buy Box offer data available for this listing.",
+        }
+
+    # Weight by competitive strength: current winner, FBA, price proximity
+    weights: List[float] = []
+    for i, offer in enumerate(offers):
+        w = 1.0
+        if offer.get("is_current_winner"):
+            w *= 4.0
+        if offer.get("is_fba") is True:
+            w *= 2.2
+        elif offer.get("is_fba") is False:
+            w *= 0.65
+        if is_amazon and i == 0:
+            w *= 2.5
+        if buy_box_price and offer.get("price"):
+            gap = abs(offer["price"] - buy_box_price) / buy_box_price
+            if gap <= 0.02:
+                w *= 1.35
+            elif gap <= 0.08:
+                w *= 1.1
+            else:
+                w *= max(0.45, 1 - gap)
+        weights.append(w)
+
+    total_w = sum(weights) or 1.0
+    raw_pcts = [round(w / total_w * 100, 1) for w in weights]
+    drift = round(100.0 - sum(raw_pcts), 1)
+    if raw_pcts:
+        raw_pcts[0] = round(raw_pcts[0] + drift, 1)
+
+    rotation = []
+    for offer, pct in zip(offers, raw_pcts):
+        rotation.append(
+            {
+                "seller": offer["name"],
+                "win_percent": pct,
+                "avg_price": offer.get("price"),
+                "is_fba": offer.get("is_fba"),
+                "fulfillment": _fba_label(offer.get("is_fba")),
+                "rating": offer.get("rating"),
+                "last_won": "Current" if offer.get("is_current_winner") else _last_won_label(pct),
+                "stock": "In stock",
+            }
+        )
+
+    rotation.sort(key=lambda x: x["win_percent"], reverse=True)
+
+    fba_count = data.get("fba_seller_count")
+    fbm_count = data.get("fbm_seller_count")
+    if fba_count is None:
+        fba_count = sum(1 for o in offers if o.get("is_fba") is True)
+    if fbm_count is None:
+        fbm_count = sum(1 for o in offers if o.get("is_fba") is False)
+
+    offers_source = data.get("offers_source", "live")
+    return {
+        "sellers": rotation,
+        "range_days": 30,
+        "eligible_fba": fba_count,
+        "eligible_fbm": fbm_count,
+        "total_sellers": max(seller_count, len(offers)),
+        "source": "live_offers" if len(offers) > 1 else "estimated",
+        "disclaimer": (
+            f"Buy Box share from {len(offers)} live Amazon offers ({offers_source}). "
+            "Track and refresh for historical rotation accuracy."
+        ),
+    }
+
+
+def _last_won_label(win_percent: float) -> str:
+    if win_percent >= 25:
+        return "1–3 days ago"
+    if win_percent >= 10:
+        return "4–7 days ago"
+    if win_percent >= 5:
+        return "1–2 weeks ago"
+    return "2+ weeks ago"

app/services/analytics/profit_calculator.py

@@ -1,360 +1,360 @@
-"""Amazon Seller Central–style revenue / profit calculator (FBA vs FBM)."""
-from __future__ import annotations
-
-from typing import Dict, Literal, Optional
-
-from app.services.analytics.amazon_fees import (
-    ProductDimensions,
-    calculate_fba_fulfillment_fee,
-    calculate_inbound_fees,
-    calculate_referral_fee,
-    calculate_removal_disposal_cost,
-    calculate_storage_fee_per_unit,
-    estimate_dimensions_from_weight,
-)
-
-FulfillmentMode = Literal["fba", "fbm"]
-Season = Literal["standard", "peak"]
-
-
-def _build_fee_section(
-    selling_price: float,
-    category: str,
-    dims: ProductDimensions,
-    mode: FulfillmentMode,
-    *,
-    season: Season = "standard",
-    inbound_region: str = "west",
-    shipping_cost_per_shipment: float = 0.0,
-    units_per_shipment: int = 1,
-    fbm_fulfillment_cost: float = 0.0,
-    avg_inventory_units: float = 1.0,
-    monthly_units_sold: float = 1.0,
-    product_cost: float = 0.0,
-    misc_cost: float = 0.0,
-    shipping_charge: float = 0.0,
-    removal_units: int = 0,
-    disposal_units: int = 0,
-) -> Dict:
-    referral = calculate_referral_fee(selling_price, category)
-    amazon_fees_total = round(
-        referral["referral_fee"]
-        + referral["fixed_closing_fee"]
-        + referral["variable_closing_fee"]
-        + referral["digital_services_fee"],
-        2,
-    )
-
-    fulfillment_block: Dict = {"fulfillment_cost": 0.0, "fba_fulfillment_fee": 0.0}
-    inbound_block: Dict = {"total_inbound_cost_per_unit": 0.0}
-    storage = calculate_storage_fee_per_unit(dims, season, avg_inventory_units, monthly_units_sold)
-
-    if mode == "fba":
-        fulfillment_block = calculate_fba_fulfillment_fee(dims.weight_lbs)
-        inbound_block = calculate_inbound_fees(inbound_region, shipping_cost_per_shipment, units_per_shipment)
-        fulfillment_total = fulfillment_block["fba_fulfillment_fee"]
-    else:
-        fulfillment_total = round(fbm_fulfillment_cost, 2)
-        fulfillment_block = {"fulfillment_cost": fulfillment_total, "fba_fulfillment_fee": 0.0}
-
-    storage_per_unit = storage["storage_cost_per_unit_sold"]
-    inbound_per_unit = inbound_block["total_inbound_cost_per_unit"] if mode == "fba" else 0.0
-    removal_block = calculate_removal_disposal_cost(removal_units, disposal_units, monthly_units_sold)
-    removal_per_unit = removal_block["removal_disposal_cost_per_unit_sold"] if mode == "fba" else 0.0
-
-    effective_revenue = selling_price + (shipping_charge if mode == "fbm" else 0.0)
-    total_costs = round(
-        amazon_fees_total
-        + fulfillment_total
-        + inbound_per_unit
-        + storage_per_unit
-        + removal_per_unit
-        + product_cost
-        + misc_cost,
-        2,
-    )
-    net_proceeds = round(effective_revenue - total_costs, 2)
-    margin = round((net_proceeds / selling_price * 100) if selling_price > 0 else 0, 1)
-    roi = round((net_proceeds / (product_cost + misc_cost) * 100) if (product_cost + misc_cost) > 0 else 0, 1)
-    breakeven = round(total_costs - (shipping_charge if mode == "fbm" else 0.0), 2)
-
-    return {
-        "fulfillment_mode": mode,
-        "item_price": selling_price,
-        "selling_price": selling_price,
-        "shipping_charge": shipping_charge if mode == "fbm" else 0.0,
-        "sales_price": round(effective_revenue, 2),
-        "amazon_fees": {
-            **referral,
-            "total": amazon_fees_total,
-        },
-        "amazon_fees_total": amazon_fees_total,
-        "referral_fee": referral["referral_fee"],
-        "referral_rate_percent": referral["referral_rate_percent"],
-        "fixed_closing_fee": referral["fixed_closing_fee"],
-        "variable_closing_fee": referral["variable_closing_fee"],
-        "digital_services_fee": referral["digital_services_fee"],
-        "fulfillment": fulfillment_block,
-        "fba_fee": fulfillment_block.get("fba_fulfillment_fee", 0),
-        "fulfillment_cost": fulfillment_block.get("fulfillment_cost", fulfillment_total),
-        "inbound": inbound_block,
-        "inbound_shipping": inbound_per_unit,
-        "storage": storage,
-        "storage_cost_per_unit": storage_per_unit,
-        "removal_disposal": removal_block if mode == "fba" else None,
-        "removal_disposal_cost_per_unit": removal_per_unit,
-        "other_costs": {
-            "cost_of_goods_sold": round(product_cost, 2),
-            "miscellaneous_cost": round(misc_cost, 2),
-            "total": round(product_cost + misc_cost, 2),
-        },
-        "product_cost": round(product_cost, 2),
-        "misc_cost": round(misc_cost, 2),
-        "total_fees": amazon_fees_total,
-        "total_costs": total_costs,
-        "cost_per_unit": total_costs,
-        "net_proceeds": net_proceeds,
-        "gross_profit": net_proceeds,
-        "net_profit": net_proceeds,
-        "profit_margin_percent": margin,
-        "net_margin_percent": margin,
-        "roi_percent": roi,
-        "breakeven_price": breakeven,
-        "is_profitable": net_proceeds > 0,
-        "verdict": (
-            "Profitable"
-            if net_proceeds > 0 and margin >= 20
-            else "Low Margin"
-            if net_proceeds > 0
-            else "Not Profitable"
-        ),
-        "formula_source": "amazon_us_2025",
-        "dimensions": {
-            "weight_lbs": dims.weight_lbs,
-            "length_in": dims.length_in,
-            "width_in": dims.width_in,
-            "height_in": dims.height_in,
-            "cubic_feet": round(dims.cubic_feet, 4),
-        },
-    }
-
-
-def calculate_profit(
-    selling_price: float,
-    product_cost: float,
-    category: str = "default",
-    weight_lbs: float = 1.0,
-    length_in: Optional[float] = None,
-    width_in: Optional[float] = None,
-    height_in: Optional[float] = None,
-    shipping_to_fba: float = 0.56,
-    additional_costs: float = 0.0,
-    fulfillment_mode: FulfillmentMode = "fba",
-    fbm_fulfillment_cost: float = 0.0,
-    storage_cost_per_unit: float = 0.0,
-    shipping_charge: float = 0.0,
-    estimated_units: int = 1,
-    season: Season = "standard",
-    inbound_region: str = "west",
-    avg_inventory_units: float = 1.0,
-    monthly_units_sold: float = 1.0,
-    units_per_shipment: int = 1,
-    removal_units: int = 0,
-    disposal_units: int = 0,
-) -> Dict:
-    if selling_price <= 0:
-        return {"error": "Invalid selling price"}
-
-    if length_in and width_in and height_in:
-        dims = ProductDimensions(weight_lbs=weight_lbs, length_in=length_in, width_in=width_in, height_in=height_in)
-    else:
-        dims = estimate_dimensions_from_weight(weight_lbs)
-
-    mode: FulfillmentMode = "fbm" if fulfillment_mode == "fbm" else "fba"
-    result = _build_fee_section(
-        selling_price,
-        category,
-        dims,
-        mode,
-        season=season,
-        inbound_region=inbound_region,
-        shipping_cost_per_shipment=shipping_to_fba if mode == "fba" else 0.0,
-        units_per_shipment=units_per_shipment,
-        fbm_fulfillment_cost=fbm_fulfillment_cost,
-        avg_inventory_units=avg_inventory_units,
-        monthly_units_sold=monthly_units_sold,
-        product_cost=product_cost,
-        misc_cost=additional_costs,
-        shipping_charge=shipping_charge,
-        removal_units=removal_units,
-        disposal_units=disposal_units,
-    )
-
-    if mode == "fba" and storage_cost_per_unit > 0 and result["storage"]["storage_cost_per_unit_sold"] == 0:
-        result["storage"]["storage_cost_per_unit_sold"] = storage_cost_per_unit
-        result["storage_cost_per_unit"] = storage_cost_per_unit
-        result["total_costs"] = round(result["total_costs"] + storage_cost_per_unit, 2)
-        result["cost_per_unit"] = result["total_costs"]
-        result["net_proceeds"] = round(result["sales_price"] - result["total_costs"], 2)
-        result["net_profit"] = result["net_proceeds"]
-        result["gross_profit"] = result["net_proceeds"]
-        result["profit_margin_percent"] = round(
-            (result["net_proceeds"] / selling_price * 100) if selling_price > 0 else 0, 1
-        )
-        result["net_margin_percent"] = result["profit_margin_percent"]
-
-    units = max(int(estimated_units), 1)
-    result["estimated_units"] = units
-    result["net_total"] = round(result["net_proceeds"] * units, 2)
-    return result
-
-
-def compare_fba_fbm(
-    selling_price: float,
-    product_cost: float,
-    category: str = "default",
-    weight_lbs: float = 1.0,
-    length_in: Optional[float] = None,
-    width_in: Optional[float] = None,
-    height_in: Optional[float] = None,
-    shipping_to_fba: float = 0.0,
-    fbm_fulfillment_cost: float = 0.0,
-    storage_cost_per_unit_fba: float = 0.0,
-    storage_cost_per_unit_fbm: float = 0.0,
-    misc_cost: float = 0.0,
-    shipping_charge: float = 0.0,
-    estimated_units: int = 1,
-    season: Season = "standard",
-    inbound_region: str = "west",
-    avg_inventory_units: float = 1.0,
-    monthly_units_sold: float = 1.0,
-    units_per_shipment: int = 1,
-    removal_units: int = 0,
-    disposal_units: int = 0,
-) -> Dict:
-    fba = calculate_profit(
-        selling_price=selling_price,
-        product_cost=product_cost,
-        category=category,
-        weight_lbs=weight_lbs,
-        length_in=length_in,
-        width_in=width_in,
-        height_in=height_in,
-        shipping_to_fba=shipping_to_fba,
-        additional_costs=misc_cost,
-        fulfillment_mode="fba",
-        storage_cost_per_unit=storage_cost_per_unit_fba,
-        season=season,
-        inbound_region=inbound_region,
-        avg_inventory_units=avg_inventory_units,
-        monthly_units_sold=monthly_units_sold,
-        units_per_shipment=units_per_shipment,
-        estimated_units=estimated_units,
-        removal_units=removal_units,
-        disposal_units=disposal_units,
-    )
-    fbm = calculate_profit(
-        selling_price=selling_price,
-        product_cost=product_cost,
-        category=category,
-        weight_lbs=weight_lbs,
-        length_in=length_in,
-        width_in=width_in,
-        height_in=height_in,
-        additional_costs=misc_cost,
-        fulfillment_mode="fbm",
-        fbm_fulfillment_cost=fbm_fulfillment_cost,
-        storage_cost_per_unit=storage_cost_per_unit_fbm,
-        shipping_charge=shipping_charge,
-        season=season,
-        avg_inventory_units=avg_inventory_units,
-        monthly_units_sold=monthly_units_sold,
-        estimated_units=estimated_units,
-    )
-
-    if fba.get("error") or fbm.get("error"):
-        return {"error": fba.get("error") or fbm.get("error")}
-
-    better = "fba" if fba["net_profit"] >= fbm["net_profit"] else "fbm"
-    margin_delta = round(fbm["net_margin_percent"] - fba["net_margin_percent"], 1)
-
-    return {
-        "selling_price": selling_price,
-        "category": category,
-        "estimated_units": estimated_units,
-        "season": season,
-        "inbound_region": inbound_region,
-        "formula_source": "amazon_us_2025",
-        "fba": fba,
-        "fbm": fbm,
-        "better_option": better,
-        "margin_delta_fbm_vs_fba": margin_delta,
-        "comparison_chart": [
-            {
-                "label": "Amazon Fulfillment (FBA)",
-                "net_profit": fba["net_profit"],
-                "net_margin": fba["net_margin_percent"],
-                "cost_per_unit": fba["cost_per_unit"],
-                "amazon_fees": fba["amazon_fees_total"],
-            },
-            {
-                "label": "Your Fulfillment (FBM)",
-                "net_profit": fbm["net_profit"],
-                "net_margin": fbm["net_margin_percent"],
-                "cost_per_unit": fbm["cost_per_unit"],
-                "amazon_fees": fbm["amazon_fees_total"],
-            },
-        ],
-    }
-
-
-def calculate_storage_cost_per_unit(
-    monthly_storage_per_unit: float = 0.0,
-    avg_inventory_units: float = 1.0,
-    monthly_units_sold: float = 1.0,
-) -> float:
-    if monthly_units_sold <= 0:
-        return 0.0
-    return round((monthly_storage_per_unit * max(avg_inventory_units, 0)) / monthly_units_sold, 2)
-
-
-def build_profit_history_series(
-    price_history: list,
-    category: str = "default",
-    weight_lbs: float = 1.0,
-    product_cost: float = 0.0,
-    misc_cost: float = 0.0,
-    season: Season = "standard",
-) -> list:
-    """FBA vs FBM net profit at each historical price point (Seller Central comparison over time)."""
-    series = []
-    for row in price_history:
-        price = row.get("price")
-        if not price or float(price) <= 0:
-            continue
-        p = float(price)
-        cmp = compare_fba_fbm(
-            selling_price=p,
-            product_cost=product_cost,
-            category=category,
-            weight_lbs=weight_lbs,
-            misc_cost=misc_cost,
-            season=season,
-            estimated_units=1,
-        )
-        if cmp.get("error"):
-            continue
-        series.append(
-            {
-                "recorded_at": row.get("recorded_at"),
-                "date": (row.get("recorded_at") or "")[:10],
-                "price": p,
-                "fba_net_profit": cmp["fba"]["net_profit"],
-                "fbm_net_profit": cmp["fbm"]["net_profit"],
-                "fba_margin": cmp["fba"]["net_margin_percent"],
-                "fbm_margin": cmp["fbm"]["net_margin_percent"],
-                "fba_cost_per_unit": cmp["fba"]["cost_per_unit"],
-                "fbm_cost_per_unit": cmp["fbm"]["cost_per_unit"],
-            }
-        )
-    return series
+"""Amazon Seller Central–style revenue / profit calculator (FBA vs FBM)."""
+from __future__ import annotations
+
+from typing import Dict, Literal, Optional
+
+from app.services.analytics.amazon_fees import (
+    ProductDimensions,
+    calculate_fba_fulfillment_fee,
+    calculate_inbound_fees,
+    calculate_referral_fee,
+    calculate_removal_disposal_cost,
+    calculate_storage_fee_per_unit,
+    estimate_dimensions_from_weight,
+)
+
+FulfillmentMode = Literal["fba", "fbm"]
+Season = Literal["standard", "peak"]
+
+
+def _build_fee_section(
+    selling_price: float,
+    category: str,
+    dims: ProductDimensions,
+    mode: FulfillmentMode,
+    *,
+    season: Season = "standard",
+    inbound_region: str = "west",
+    shipping_cost_per_shipment: float = 0.0,
+    units_per_shipment: int = 1,
+    fbm_fulfillment_cost: float = 0.0,
+    avg_inventory_units: float = 1.0,
+    monthly_units_sold: float = 1.0,
+    product_cost: float = 0.0,
+    misc_cost: float = 0.0,
+    shipping_charge: float = 0.0,
+    removal_units: int = 0,
+    disposal_units: int = 0,
+) -> Dict:
+    referral = calculate_referral_fee(selling_price, category)
+    amazon_fees_total = round(
+        referral["referral_fee"]
+        + referral["fixed_closing_fee"]
+        + referral["variable_closing_fee"]
+        + referral["digital_services_fee"],
+        2,
+    )
+
+    fulfillment_block: Dict = {"fulfillment_cost": 0.0, "fba_fulfillment_fee": 0.0}
+    inbound_block: Dict = {"total_inbound_cost_per_unit": 0.0}
+    storage = calculate_storage_fee_per_unit(dims, season, avg_inventory_units, monthly_units_sold)
+
+    if mode == "fba":
+        fulfillment_block = calculate_fba_fulfillment_fee(dims.weight_lbs)
+        inbound_block = calculate_inbound_fees(inbound_region, shipping_cost_per_shipment, units_per_shipment)
+        fulfillment_total = fulfillment_block["fba_fulfillment_fee"]
+    else:
+        fulfillment_total = round(fbm_fulfillment_cost, 2)
+        fulfillment_block = {"fulfillment_cost": fulfillment_total, "fba_fulfillment_fee": 0.0}
+
+    storage_per_unit = storage["storage_cost_per_unit_sold"]
+    inbound_per_unit = inbound_block["total_inbound_cost_per_unit"] if mode == "fba" else 0.0
+    removal_block = calculate_removal_disposal_cost(removal_units, disposal_units, monthly_units_sold)
+    removal_per_unit = removal_block["removal_disposal_cost_per_unit_sold"] if mode == "fba" else 0.0
+
+    effective_revenue = selling_price + (shipping_charge if mode == "fbm" else 0.0)
+    total_costs = round(
+        amazon_fees_total
+        + fulfillment_total
+        + inbound_per_unit
+        + storage_per_unit
+        + removal_per_unit
+        + product_cost
+        + misc_cost,
+        2,
+    )
+    net_proceeds = round(effective_revenue - total_costs, 2)
+    margin = round((net_proceeds / selling_price * 100) if selling_price > 0 else 0, 1)
+    roi = round((net_proceeds / (product_cost + misc_cost) * 100) if (product_cost + misc_cost) > 0 else 0, 1)
+    breakeven = round(total_costs - (shipping_charge if mode == "fbm" else 0.0), 2)
+
+    return {
+        "fulfillment_mode": mode,
+        "item_price": selling_price,
+        "selling_price": selling_price,
+        "shipping_charge": shipping_charge if mode == "fbm" else 0.0,
+        "sales_price": round(effective_revenue, 2),
+        "amazon_fees": {
+            **referral,
+            "total": amazon_fees_total,
+        },
+        "amazon_fees_total": amazon_fees_total,
+        "referral_fee": referral["referral_fee"],
+        "referral_rate_percent": referral["referral_rate_percent"],
+        "fixed_closing_fee": referral["fixed_closing_fee"],
+        "variable_closing_fee": referral["variable_closing_fee"],
+        "digital_services_fee": referral["digital_services_fee"],
+        "fulfillment": fulfillment_block,
+        "fba_fee": fulfillment_block.get("fba_fulfillment_fee", 0),
+        "fulfillment_cost": fulfillment_block.get("fulfillment_cost", fulfillment_total),
+        "inbound": inbound_block,
+        "inbound_shipping": inbound_per_unit,
+        "storage": storage,
+        "storage_cost_per_unit": storage_per_unit,
+        "removal_disposal": removal_block if mode == "fba" else None,
+        "removal_disposal_cost_per_unit": removal_per_unit,
+        "other_costs": {
+            "cost_of_goods_sold": round(product_cost, 2),
+            "miscellaneous_cost": round(misc_cost, 2),
+            "total": round(product_cost + misc_cost, 2),
+        },
+        "product_cost": round(product_cost, 2),
+        "misc_cost": round(misc_cost, 2),
+        "total_fees": amazon_fees_total,
+        "total_costs": total_costs,
+        "cost_per_unit": total_costs,
+        "net_proceeds": net_proceeds,
+        "gross_profit": net_proceeds,
+        "net_profit": net_proceeds,
+        "profit_margin_percent": margin,
+        "net_margin_percent": margin,
+        "roi_percent": roi,
+        "breakeven_price": breakeven,
+        "is_profitable": net_proceeds > 0,
+        "verdict": (
+            "Profitable"
+            if net_proceeds > 0 and margin >= 20
+            else "Low Margin"
+            if net_proceeds > 0
+            else "Not Profitable"
+        ),
+        "formula_source": "amazon_us_2025",
+        "dimensions": {
+            "weight_lbs": dims.weight_lbs,
+            "length_in": dims.length_in,
+            "width_in": dims.width_in,
+            "height_in": dims.height_in,
+            "cubic_feet": round(dims.cubic_feet, 4),
+        },
+    }
+
+
+def calculate_profit(
+    selling_price: float,
+    product_cost: float,
+    category: str = "default",
+    weight_lbs: float = 1.0,
+    length_in: Optional[float] = None,
+    width_in: Optional[float] = None,
+    height_in: Optional[float] = None,
+    shipping_to_fba: float = 0.56,
+    additional_costs: float = 0.0,
+    fulfillment_mode: FulfillmentMode = "fba",
+    fbm_fulfillment_cost: float = 0.0,
+    storage_cost_per_unit: float = 0.0,
+    shipping_charge: float = 0.0,
+    estimated_units: int = 1,
+    season: Season = "standard",
+    inbound_region: str = "west",
+    avg_inventory_units: float = 1.0,
+    monthly_units_sold: float = 1.0,
+    units_per_shipment: int = 1,
+    removal_units: int = 0,
+    disposal_units: int = 0,
+) -> Dict:
+    if selling_price <= 0:
+        return {"error": "Invalid selling price"}
+
+    if length_in and width_in and height_in:
+        dims = ProductDimensions(weight_lbs=weight_lbs, length_in=length_in, width_in=width_in, height_in=height_in)
+    else:
+        dims = estimate_dimensions_from_weight(weight_lbs)
+
+    mode: FulfillmentMode = "fbm" if fulfillment_mode == "fbm" else "fba"
+    result = _build_fee_section(
+        selling_price,
+        category,
+        dims,
+        mode,
+        season=season,
+        inbound_region=inbound_region,
+        shipping_cost_per_shipment=shipping_to_fba if mode == "fba" else 0.0,
+        units_per_shipment=units_per_shipment,
+        fbm_fulfillment_cost=fbm_fulfillment_cost,
+        avg_inventory_units=avg_inventory_units,
+        monthly_units_sold=monthly_units_sold,
+        product_cost=product_cost,
+        misc_cost=additional_costs,
+        shipping_charge=shipping_charge,
+        removal_units=removal_units,
+        disposal_units=disposal_units,
+    )
+
+    if mode == "fba" and storage_cost_per_unit > 0 and result["storage"]["storage_cost_per_unit_sold"] == 0:
+        result["storage"]["storage_cost_per_unit_sold"] = storage_cost_per_unit
+        result["storage_cost_per_unit"] = storage_cost_per_unit
+        result["total_costs"] = round(result["total_costs"] + storage_cost_per_unit, 2)
+        result["cost_per_unit"] = result["total_costs"]
+        result["net_proceeds"] = round(result["sales_price"] - result["total_costs"], 2)
+        result["net_profit"] = result["net_proceeds"]
+        result["gross_profit"] = result["net_proceeds"]
+        result["profit_margin_percent"] = round(
+            (result["net_proceeds"] / selling_price * 100) if selling_price > 0 else 0, 1
+        )
+        result["net_margin_percent"] = result["profit_margin_percent"]
+
+    units = max(int(estimated_units), 1)
+    result["estimated_units"] = units
+    result["net_total"] = round(result["net_proceeds"] * units, 2)
+    return result
+
+
+def compare_fba_fbm(
+    selling_price: float,
+    product_cost: float,
+    category: str = "default",
+    weight_lbs: float = 1.0,
+    length_in: Optional[float] = None,
+    width_in: Optional[float] = None,
+    height_in: Optional[float] = None,
+    shipping_to_fba: float = 0.0,
+    fbm_fulfillment_cost: float = 0.0,
+    storage_cost_per_unit_fba: float = 0.0,
+    storage_cost_per_unit_fbm: float = 0.0,
+    misc_cost: float = 0.0,
+    shipping_charge: float = 0.0,
+    estimated_units: int = 1,
+    season: Season = "standard",
+    inbound_region: str = "west",
+    avg_inventory_units: float = 1.0,
+    monthly_units_sold: float = 1.0,
+    units_per_shipment: int = 1,
+    removal_units: int = 0,
+    disposal_units: int = 0,
+) -> Dict:
+    fba = calculate_profit(
+        selling_price=selling_price,
+        product_cost=product_cost,
+        category=category,
+        weight_lbs=weight_lbs,
+        length_in=length_in,
+        width_in=width_in,
+        height_in=height_in,
+        shipping_to_fba=shipping_to_fba,
+        additional_costs=misc_cost,
+        fulfillment_mode="fba",
+        storage_cost_per_unit=storage_cost_per_unit_fba,
+        season=season,
+        inbound_region=inbound_region,
+        avg_inventory_units=avg_inventory_units,
+        monthly_units_sold=monthly_units_sold,
+        units_per_shipment=units_per_shipment,
+        estimated_units=estimated_units,
+        removal_units=removal_units,
+        disposal_units=disposal_units,
+    )
+    fbm = calculate_profit(
+        selling_price=selling_price,
+        product_cost=product_cost,
+        category=category,
+        weight_lbs=weight_lbs,
+        length_in=length_in,
+        width_in=width_in,
+        height_in=height_in,
+        additional_costs=misc_cost,
+        fulfillment_mode="fbm",
+        fbm_fulfillment_cost=fbm_fulfillment_cost,
+        storage_cost_per_unit=storage_cost_per_unit_fbm,
+        shipping_charge=shipping_charge,
+        season=season,
+        avg_inventory_units=avg_inventory_units,
+        monthly_units_sold=monthly_units_sold,
+        estimated_units=estimated_units,
+    )
+
+    if fba.get("error") or fbm.get("error"):
+        return {"error": fba.get("error") or fbm.get("error")}
+
+    better = "fba" if fba["net_profit"] >= fbm["net_profit"] else "fbm"
+    margin_delta = round(fbm["net_margin_percent"] - fba["net_margin_percent"], 1)
+
+    return {
+        "selling_price": selling_price,
+        "category": category,
+        "estimated_units": estimated_units,
+        "season": season,
+        "inbound_region": inbound_region,
+        "formula_source": "amazon_us_2025",
+        "fba": fba,
+        "fbm": fbm,
+        "better_option": better,
+        "margin_delta_fbm_vs_fba": margin_delta,
+        "comparison_chart": [
+            {
+                "label": "Amazon Fulfillment (FBA)",
+                "net_profit": fba["net_profit"],
+                "net_margin": fba["net_margin_percent"],
+                "cost_per_unit": fba["cost_per_unit"],
+                "amazon_fees": fba["amazon_fees_total"],
+            },
+            {
+                "label": "Your Fulfillment (FBM)",
+                "net_profit": fbm["net_profit"],
+                "net_margin": fbm["net_margin_percent"],
+                "cost_per_unit": fbm["cost_per_unit"],
+                "amazon_fees": fbm["amazon_fees_total"],
+            },
+        ],
+    }
+
+
+def calculate_storage_cost_per_unit(
+    monthly_storage_per_unit: float = 0.0,
+    avg_inventory_units: float = 1.0,
+    monthly_units_sold: float = 1.0,
+) -> float:
+    if monthly_units_sold <= 0:
+        return 0.0
+    return round((monthly_storage_per_unit * max(avg_inventory_units, 0)) / monthly_units_sold, 2)
+
+
+def build_profit_history_series(
+    price_history: list,
+    category: str = "default",
+    weight_lbs: float = 1.0,
+    product_cost: float = 0.0,
+    misc_cost: float = 0.0,
+    season: Season = "standard",
+) -> list:
+    """FBA vs FBM net profit at each historical price point (Seller Central comparison over time)."""
+    series = []
+    for row in price_history:
+        price = row.get("price")
+        if not price or float(price) <= 0:
+            continue
+        p = float(price)
+        cmp = compare_fba_fbm(
+            selling_price=p,
+            product_cost=product_cost,
+            category=category,
+            weight_lbs=weight_lbs,
+            misc_cost=misc_cost,
+            season=season,
+            estimated_units=1,
+        )
+        if cmp.get("error"):
+            continue
+        series.append(
+            {
+                "recorded_at": row.get("recorded_at"),
+                "date": (row.get("recorded_at") or "")[:10],
+                "price": p,
+                "fba_net_profit": cmp["fba"]["net_profit"],
+                "fbm_net_profit": cmp["fbm"]["net_profit"],
+                "fba_margin": cmp["fba"]["net_margin_percent"],
+                "fbm_margin": cmp["fbm"]["net_margin_percent"],
+                "fba_cost_per_unit": cmp["fba"]["cost_per_unit"],
+                "fbm_cost_per_unit": cmp["fbm"]["cost_per_unit"],
+            }
+        )
+    return series

app/services/analytics/tracking_service.py

@@ -1,73 +1,73 @@
-from sqlalchemy.orm import Session
-from app.models.product import PriceHistory, TrackedProduct, Product
-from app.models.tracking import PriceAlert
-from datetime import datetime, timezone
-import uuid
-
-
-def record_price(db: Session, asin: str, price: float, bsr: int = None, reviews: int = None, rating: float = None):
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        return None
-    entry = PriceHistory(
-        id=str(uuid.uuid4()),
-        product_id=str(product.id),
-        price=price,
-        bsr=bsr,
-        review_count=reviews,
-        rating=rating,
-    )
-    db.add(entry)
-    db.commit()
-    return entry
-
-
-def get_price_history(db: Session, asin: str, days: int = 30):
-    from datetime import timedelta
-    product = db.query(Product).filter(Product.asin == asin).first()
-    if not product:
-        return []
-    since = datetime.now(timezone.utc) - timedelta(days=days)
-    rows = db.query(PriceHistory).filter(
-        PriceHistory.product_id == product.id,
-        PriceHistory.recorded_at >= since
-    ).order_by(PriceHistory.recorded_at.asc()).all()
-    return [{"date": r.recorded_at.isoformat(), "price": float(r.price) if r.price else None, "bsr": r.bsr, "reviews": r.review_count, "rating": float(r.rating) if r.rating else None} for r in rows]
-
-
-def create_alert(db: Session, user_id: str, asin: str, alert_type: str, threshold: float):
-    alert = PriceAlert(user_id=user_id, asin=asin, alert_type=alert_type, threshold=threshold)
-    db.add(alert)
-    db.commit()
-    return alert
-
-
-def get_alerts(db: Session, user_id: str):
-    return db.query(PriceAlert).filter(PriceAlert.user_id == user_id, PriceAlert.is_active == True).all()
-
-
-def check_alerts(db: Session, asin: str, current_price: float, current_bsr: int = None):
-    alerts = db.query(PriceAlert).filter(PriceAlert.asin == asin, PriceAlert.is_active == True, PriceAlert.triggered == False).all()
-    triggered = []
-    for alert in alerts:
-        if alert.alert_type == "price_drop" and current_price <= alert.threshold:
-            alert.triggered = True
-            alert.triggered_at = datetime.now(timezone.utc)
-            triggered.append({"type": "price_drop", "asin": asin, "price": current_price})
-        elif alert.alert_type == "bsr_improve" and current_bsr and current_bsr <= alert.threshold:
-            alert.triggered = True
-            alert.triggered_at = datetime.now(timezone.utc)
-            triggered.append({"type": "bsr_improve", "asin": asin, "bsr": current_bsr})
-    db.commit()
-    return triggered
-
-
-def get_tracked_products(db: Session, user_id: str):
-    tracked = db.query(TrackedProduct).filter(TrackedProduct.user_id == user_id).all()
-    result = []
-    for t in tracked:
-        product = db.query(Product).filter(Product.id == t.product_id).first()
-        if product:
-            latest = db.query(PriceHistory).filter(PriceHistory.product_id == product.id).order_by(PriceHistory.recorded_at.desc()).first()
-            result.append({"asin": product.asin, "title": product.title, "price": float(latest.price) if latest and latest.price else None, "bsr": latest.bsr if latest else None, "tracked_at": t.tracked_at.isoformat() if t.tracked_at else None})
+from sqlalchemy.orm import Session
+from app.models.product import PriceHistory, TrackedProduct, Product
+from app.models.tracking import PriceAlert
+from datetime import datetime, timezone
+import uuid
+
+
+def record_price(db: Session, asin: str, price: float, bsr: int = None, reviews: int = None, rating: float = None):
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        return None
+    entry = PriceHistory(
+        id=str(uuid.uuid4()),
+        product_id=str(product.id),
+        price=price,
+        bsr=bsr,
+        review_count=reviews,
+        rating=rating,
+    )
+    db.add(entry)
+    db.commit()
+    return entry
+
+
+def get_price_history(db: Session, asin: str, days: int = 30):
+    from datetime import timedelta
+    product = db.query(Product).filter(Product.asin == asin).first()
+    if not product:
+        return []
+    since = datetime.now(timezone.utc) - timedelta(days=days)
+    rows = db.query(PriceHistory).filter(
+        PriceHistory.product_id == product.id,
+        PriceHistory.recorded_at >= since
+    ).order_by(PriceHistory.recorded_at.asc()).all()
+    return [{"date": r.recorded_at.isoformat(), "price": float(r.price) if r.price else None, "bsr": r.bsr, "reviews": r.review_count, "rating": float(r.rating) if r.rating else None} for r in rows]
+
+
+def create_alert(db: Session, user_id: str, asin: str, alert_type: str, threshold: float):
+    alert = PriceAlert(user_id=user_id, asin=asin, alert_type=alert_type, threshold=threshold)
+    db.add(alert)
+    db.commit()
+    return alert
+
+
+def get_alerts(db: Session, user_id: str):
+    return db.query(PriceAlert).filter(PriceAlert.user_id == user_id, PriceAlert.is_active == True).all()
+
+
+def check_alerts(db: Session, asin: str, current_price: float, current_bsr: int = None):
+    alerts = db.query(PriceAlert).filter(PriceAlert.asin == asin, PriceAlert.is_active == True, PriceAlert.triggered == False).all()
+    triggered = []
+    for alert in alerts:
+        if alert.alert_type == "price_drop" and current_price <= alert.threshold:
+            alert.triggered = True
+            alert.triggered_at = datetime.now(timezone.utc)
+            triggered.append({"type": "price_drop", "asin": asin, "price": current_price})
+        elif alert.alert_type == "bsr_improve" and current_bsr and current_bsr <= alert.threshold:
+            alert.triggered = True
+            alert.triggered_at = datetime.now(timezone.utc)
+            triggered.append({"type": "bsr_improve", "asin": asin, "bsr": current_bsr})
+    db.commit()
+    return triggered
+
+
+def get_tracked_products(db: Session, user_id: str):
+    tracked = db.query(TrackedProduct).filter(TrackedProduct.user_id == user_id).all()
+    result = []
+    for t in tracked:
+        product = db.query(Product).filter(Product.id == t.product_id).first()
+        if product:
+            latest = db.query(PriceHistory).filter(PriceHistory.product_id == product.id).order_by(PriceHistory.recorded_at.desc()).first()
+            result.append({"asin": product.asin, "title": product.title, "price": float(latest.price) if latest and latest.price else None, "bsr": latest.bsr if latest else None, "tracked_at": t.tracked_at.isoformat() if t.tracked_at else None})
     return result

app/services/llm_service.py

@@ -1,198 +1,198 @@
-"""Central LLM service for Rankora.
-
-Supports Google Gemini (default), OpenAI, and Anthropic.
-Set exactly one API key in backend/.env to enable real LLM responses.
-"""
-from __future__ import annotations
-
-import json
-import re
-from typing import Any, Dict, List, Optional, Tuple
-
-from app.config import settings
-
-Message = Dict[str, str]
-
-
-def is_llm_available() -> bool:
-    return bool(settings.gemini_api_key or settings.openai_api_key or settings.anthropic_api_key)
-
-
-def get_active_provider() -> Optional[str]:
-    if settings.gemini_api_key:
-        return "gemini"
-    if settings.anthropic_api_key:
-        return "anthropic"
-    if settings.openai_api_key:
-        return "openai"
-    return None
-
-
-def _model_for(provider: str) -> str:
-    model = (settings.ai_model or "").strip()
-    if model:
-        return model
-    defaults = {
-        "gemini": "gemini-2.0-flash",
-        "anthropic": "claude-3-5-sonnet-latest",
-        "openai": "gpt-4o-mini",
-    }
-    return defaults[provider]
-
-
-def generate_text(
-    system: str,
-    user: str,
-    history: Optional[List[Message]] = None,
-    *,
-    max_tokens: int = 1536,
-    temperature: float = 0.35,
-) -> Tuple[Optional[str], Optional[str]]:
-    """Return (text, provider) or (None, None) if no key or all providers fail."""
-    history = history or []
-    provider = get_active_provider()
-    if not provider:
-        return None, None
-
-    if provider == "gemini":
-        text = _gemini_text(system, user, history, max_tokens, temperature)
-        return (text, "gemini") if text else _fallback_chain(system, user, history, max_tokens, temperature, skip="gemini")
-
-    if provider == "anthropic":
-        text = _anthropic_text(system, user, history, max_tokens, temperature)
-        return (text, "anthropic") if text else _fallback_chain(system, user, history, max_tokens, temperature, skip="anthropic")
-
-    text = _openai_text(system, user, history, max_tokens, temperature)
-    return (text, "openai") if text else _fallback_chain(system, user, history, max_tokens, temperature, skip="openai")
-
-
-def generate_json(
-    system: str,
-    user: str,
-    *,
-    max_tokens: int = 2048,
-) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
-    """Ask the LLM for a JSON object. Returns (parsed_dict, provider)."""
-    prompt = (
-        f"{user}\n\n"
-        "Respond with ONLY valid JSON — no markdown fences, no commentary."
-    )
-    raw, provider = generate_text(system, prompt, max_tokens=max_tokens, temperature=0.2)
-    if not raw:
-        return None, None
-    parsed = _parse_json_object(raw)
-    return parsed, provider
-
-
-def _fallback_chain(
-    system: str,
-    user: str,
-    history: List[Message],
-    max_tokens: int,
-    temperature: float,
-    skip: str,
-) -> Tuple[Optional[str], Optional[str]]:
-    order = [p for p in ("gemini", "anthropic", "openai") if p != skip]
-    for provider in order:
-        if provider == "gemini" and not settings.gemini_api_key:
-            continue
-        if provider == "anthropic" and not settings.anthropic_api_key:
-            continue
-        if provider == "openai" and not settings.openai_api_key:
-            continue
-        fn = {"gemini": _gemini_text, "anthropic": _anthropic_text, "openai": _openai_text}[provider]
-        text = fn(system, user, history, max_tokens, temperature)
-        if text:
-            return text, provider
-    return None, None
-
-
-def _gemini_text(system: str, user: str, history: List[Message], max_tokens: int, temperature: float) -> Optional[str]:
-    if not settings.gemini_api_key:
-        return None
-    try:
-        import google.generativeai as genai
-
-        genai.configure(api_key=settings.gemini_api_key)
-        model = genai.GenerativeModel(
-            _model_for("gemini"),
-            system_instruction=system,
-        )
-        chat_history = []
-        for msg in history[-8:]:
-            role = msg.get("role")
-            if role not in ("user", "assistant"):
-                continue
-            chat_history.append({"role": "user" if role == "user" else "model", "parts": [msg["content"]]})
-        chat = model.start_chat(history=chat_history)
-        resp = chat.send_message(
-            user,
-            generation_config={"max_output_tokens": max_tokens, "temperature": temperature},
-        )
-        return (resp.text or "").strip() or None
-    except Exception as e:
-        print(f"[llm_service] gemini failed: {e}")
-        return None
-
-
-def _anthropic_text(system: str, user: str, history: List[Message], max_tokens: int, temperature: float) -> Optional[str]:
-    if not settings.anthropic_api_key:
-        return None
-    try:
-        import anthropic
-
-        client = anthropic.Anthropic(api_key=settings.anthropic_api_key)
-        msgs = [{"role": m["role"], "content": m["content"]} for m in history[-8:] if m.get("role") in ("user", "assistant")]
-        msgs.append({"role": "user", "content": user})
-        resp = client.messages.create(
-            model=_model_for("anthropic"),
-            max_tokens=max_tokens,
-            temperature=temperature,
-            system=system,
-            messages=msgs,
-        )
-        return "".join(getattr(b, "text", "") for b in resp.content).strip() or None
-    except Exception as e:
-        print(f"[llm_service] anthropic failed: {e}")
-        return None
-
-
-def _openai_text(system: str, user: str, history: List[Message], max_tokens: int, temperature: float) -> Optional[str]:
-    if not settings.openai_api_key:
-        return None
-    try:
-        from openai import OpenAI
-
-        client = OpenAI(api_key=settings.openai_api_key, base_url=settings.openai_base_url or None)
-        msgs: List[Dict[str, str]] = [{"role": "system", "content": system}]
-        msgs += [{"role": m["role"], "content": m["content"]} for m in history[-8:] if m.get("role") in ("user", "assistant")]
-        msgs.append({"role": "user", "content": user})
-        resp = client.chat.completions.create(
-            model=_model_for("openai"),
-            messages=msgs,
-            max_tokens=max_tokens,
-            temperature=temperature,
-        )
-        return (resp.choices[0].message.content or "").strip() or None
-    except Exception as e:
-        print(f"[llm_service] openai failed: {e}")
-        return None
-
-
-def _parse_json_object(raw: str) -> Optional[Dict[str, Any]]:
-    text = raw.strip()
-    fence = re.search(r"```(?:json)?\s*([\s\S]*?)```", text)
-    if fence:
-        text = fence.group(1).strip()
-    try:
-        data = json.loads(text)
-        return data if isinstance(data, dict) else None
-    except json.JSONDecodeError:
-        start, end = text.find("{"), text.rfind("}")
-        if start >= 0 and end > start:
-            try:
-                data = json.loads(text[start : end + 1])
-                return data if isinstance(data, dict) else None
-            except json.JSONDecodeError:
-                return None
-    return None
+"""Central LLM service for Rankora.
+
+Supports Google Gemini (default), OpenAI, and Anthropic.
+Set exactly one API key in backend/.env to enable real LLM responses.
+"""
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from app.config import settings
+
+Message = Dict[str, str]
+
+
+def is_llm_available() -> bool:
+    return bool(settings.gemini_api_key or settings.openai_api_key or settings.anthropic_api_key)
+
+
+def get_active_provider() -> Optional[str]:
+    if settings.gemini_api_key:
+        return "gemini"
+    if settings.anthropic_api_key:
+        return "anthropic"
+    if settings.openai_api_key:
+        return "openai"
+    return None
+
+
+def _model_for(provider: str) -> str:
+    model = (settings.ai_model or "").strip()
+    if model:
+        return model
+    defaults = {
+        "gemini": "gemini-2.0-flash",
+        "anthropic": "claude-3-5-sonnet-latest",
+        "openai": "gpt-4o-mini",
+    }
+    return defaults[provider]
+
+
+def generate_text(
+    system: str,
+    user: str,
+    history: Optional[List[Message]] = None,
+    *,
+    max_tokens: int = 1536,
+    temperature: float = 0.35,
+) -> Tuple[Optional[str], Optional[str]]:
+    """Return (text, provider) or (None, None) if no key or all providers fail."""
+    history = history or []
+    provider = get_active_provider()
+    if not provider:
+        return None, None
+
+    if provider == "gemini":
+        text = _gemini_text(system, user, history, max_tokens, temperature)
+        return (text, "gemini") if text else _fallback_chain(system, user, history, max_tokens, temperature, skip="gemini")
+
+    if provider == "anthropic":
+        text = _anthropic_text(system, user, history, max_tokens, temperature)
+        return (text, "anthropic") if text else _fallback_chain(system, user, history, max_tokens, temperature, skip="anthropic")
+
+    text = _openai_text(system, user, history, max_tokens, temperature)
+    return (text, "openai") if text else _fallback_chain(system, user, history, max_tokens, temperature, skip="openai")
+
+
+def generate_json(
+    system: str,
+    user: str,
+    *,
+    max_tokens: int = 2048,
+) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
+    """Ask the LLM for a JSON object. Returns (parsed_dict, provider)."""
+    prompt = (
+        f"{user}\n\n"
+        "Respond with ONLY valid JSON — no markdown fences, no commentary."
+    )
+    raw, provider = generate_text(system, prompt, max_tokens=max_tokens, temperature=0.2)
+    if not raw:
+        return None, None
+    parsed = _parse_json_object(raw)
+    return parsed, provider
+
+
+def _fallback_chain(
+    system: str,
+    user: str,
+    history: List[Message],
+    max_tokens: int,
+    temperature: float,
+    skip: str,
+) -> Tuple[Optional[str], Optional[str]]:
+    order = [p for p in ("gemini", "anthropic", "openai") if p != skip]
+    for provider in order:
+        if provider == "gemini" and not settings.gemini_api_key:
+            continue
+        if provider == "anthropic" and not settings.anthropic_api_key:
+            continue
+        if provider == "openai" and not settings.openai_api_key:
+            continue
+        fn = {"gemini": _gemini_text, "anthropic": _anthropic_text, "openai": _openai_text}[provider]
+        text = fn(system, user, history, max_tokens, temperature)
+        if text:
+            return text, provider
+    return None, None
+
+
+def _gemini_text(system: str, user: str, history: List[Message], max_tokens: int, temperature: float) -> Optional[str]:
+    if not settings.gemini_api_key:
+        return None
+    try:
+        import google.generativeai as genai
+
+        genai.configure(api_key=settings.gemini_api_key)
+        model = genai.GenerativeModel(
+            _model_for("gemini"),
+            system_instruction=system,
+        )
+        chat_history = []
+        for msg in history[-8:]:
+            role = msg.get("role")
+            if role not in ("user", "assistant"):
+                continue
+            chat_history.append({"role": "user" if role == "user" else "model", "parts": [msg["content"]]})
+        chat = model.start_chat(history=chat_history)
+        resp = chat.send_message(
+            user,
+            generation_config={"max_output_tokens": max_tokens, "temperature": temperature},
+        )
+        return (resp.text or "").strip() or None
+    except Exception as e:
+        print(f"[llm_service] gemini failed: {e}")
+        return None
+
+
+def _anthropic_text(system: str, user: str, history: List[Message], max_tokens: int, temperature: float) -> Optional[str]:
+    if not settings.anthropic_api_key:
+        return None
+    try:
+        import anthropic
+
+        client = anthropic.Anthropic(api_key=settings.anthropic_api_key)
+        msgs = [{"role": m["role"], "content": m["content"]} for m in history[-8:] if m.get("role") in ("user", "assistant")]
+        msgs.append({"role": "user", "content": user})
+        resp = client.messages.create(
+            model=_model_for("anthropic"),
+            max_tokens=max_tokens,
+            temperature=temperature,
+            system=system,
+            messages=msgs,
+        )
+        return "".join(getattr(b, "text", "") for b in resp.content).strip() or None
+    except Exception as e:
+        print(f"[llm_service] anthropic failed: {e}")
+        return None
+
+
+def _openai_text(system: str, user: str, history: List[Message], max_tokens: int, temperature: float) -> Optional[str]:
+    if not settings.openai_api_key:
+        return None
+    try:
+        from openai import OpenAI
+
+        client = OpenAI(api_key=settings.openai_api_key, base_url=settings.openai_base_url or None)
+        msgs: List[Dict[str, str]] = [{"role": "system", "content": system}]
+        msgs += [{"role": m["role"], "content": m["content"]} for m in history[-8:] if m.get("role") in ("user", "assistant")]
+        msgs.append({"role": "user", "content": user})
+        resp = client.chat.completions.create(
+            model=_model_for("openai"),
+            messages=msgs,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+        return (resp.choices[0].message.content or "").strip() or None
+    except Exception as e:
+        print(f"[llm_service] openai failed: {e}")
+        return None
+
+
+def _parse_json_object(raw: str) -> Optional[Dict[str, Any]]:
+    text = raw.strip()
+    fence = re.search(r"```(?:json)?\s*([\s\S]*?)```", text)
+    if fence:
+        text = fence.group(1).strip()
+    try:
+        data = json.loads(text)
+        return data if isinstance(data, dict) else None
+    except json.JSONDecodeError:
+        start, end = text.find("{"), text.rfind("}")
+        if start >= 0 and end > start:
+            try:
+                data = json.loads(text[start : end + 1])
+                return data if isinstance(data, dict) else None
+            except json.JSONDecodeError:
+                return None
+    return None

app/services/ml/demand_forecaster.py

@@ -1,233 +1,233 @@
-# app/services/ml/demand_forecaster.py
-# ─────────────────────────────────────────────────────────────────────────────
-# Demand Forecasting — predicts monthly unit sales for next 3 months.
-# Uses BSR → sales relationship (Jungle Scout / Helium 10 methodology)
-# combined with seasonal adjustments and trend momentum.
-# ─────────────────────────────────────────────────────────────────────────────
-
-import math
-from datetime import datetime
-from typing import Optional
-
-
-# Seasonal multipliers by month (empirical Amazon sales data)
-_SEASONALITY = {
-    1:  0.78,   # January  — post-holiday slump
-    2:  0.80,   # February
-    3:  0.88,   # March    — spring pickup
-    4:  0.90,   # April
-    5:  0.95,   # May      — Mother's Day boost
-    6:  0.88,   # June
-    7:  0.85,   # July     — Prime Day offset
-    8:  0.87,   # August   — back to school
-    9:  0.90,   # September
-    10: 1.05,   # October  — pre-holiday
-    11: 1.35,   # November — Black Friday / Cyber Monday
-    12: 1.45,   # December — peak holiday
-}
-
-# BSR to monthly units table (calibrated from Jungle Scout data)
-# Format: (bsr_min, bsr_max, base_monthly_units)
-_BSR_SALES_TABLE = [
-    (1,         100,        8500),
-    (100,       500,        4500),
-    (500,       1_000,      2800),
-    (1_000,     3_000,      1500),
-    (3_000,     5_000,      800),
-    (5_000,     10_000,     400),
-    (10_000,    25_000,     180),
-    (25_000,    50_000,     85),
-    (50_000,    100_000,    40),
-    (100_000,   250_000,    18),
-    (250_000,   500_000,    8),
-    (500_000,   1_000_000,  3),
-    (1_000_000, float("inf"), 1),
-]
-
-
-def _bsr_to_units(bsr: int) -> int:
-    for low, high, units in _BSR_SALES_TABLE:
-        if low <= bsr < high:
-            # Interpolate within the bracket
-            fraction = (bsr - low) / (high - low) if high != float("inf") else 0
-            # Units decrease as BSR increases within bracket
-            next_units = _BSR_SALES_TABLE[_BSR_SALES_TABLE.index((low, high, units)) + 1][2] \
-                         if high != float("inf") else 1
-            return max(1, int(units - fraction * (units - next_units)))
-    return 1
-
-
-def forecast_demand(
-    bsr: Optional[int],
-    category: str = "",
-    review_count: int = 0,
-    rating: float = 0.0,
-    price: float = 0.0,
-    history: Optional[list] = None,
-) -> dict:
-    """
-    Forecast monthly demand for the next 3 months.
-
-    Returns unit estimates, revenue estimates, trend direction,
-    and seasonal analysis.
-    """
-    if not bsr or bsr <= 0:
-        return _empty_forecast()
-
-    # ── Base sales from BSR ──────────────────────────────────────────────────
-    base_units = _bsr_to_units(bsr)
-
-    # ── Trend from BSR history ───────────────────────────────────────────────
-    trend_multiplier  = 1.0
-    trend_description = "stable"
-    trend_confidence  = 50
-
-    if history and len(history) >= 3:
-        bsr_values = [h.get("bsr") for h in history if h.get("bsr") and h["bsr"] > 0]
-        if len(bsr_values) >= 3:
-            # Lower BSR over time = improving sales = positive trend
-            recent  = bsr_values[:3]    # most recent 3
-            older   = bsr_values[-3:]   # oldest 3
-            avg_recent = sum(recent) / len(recent)
-            avg_older  = sum(older) / len(older)
-            if avg_older > 0:
-                change = (avg_older - avg_recent) / avg_older  # positive = BSR improving
-                trend_multiplier  = 1.0 + change * 0.3   # up to ±30% adjustment
-                trend_multiplier  = max(0.5, min(1.5, trend_multiplier))
-                trend_confidence  = 75
-                if change > 0.1:
-                    trend_description = "growing"
-                elif change < -0.1:
-                    trend_description = "declining"
-
-    # ── Review momentum multiplier ───────────────────────────────────────────
-    # High review count relative to BSR = loyal buyers = stable demand
-    review_mult = 1.0
-    if review_count > 1000:
-        review_mult = 1.08
-    elif review_count > 500:
-        review_mult = 1.04
-    elif review_count < 10:
-        review_mult = 0.92  # low review count = product is new/uncertain
-
-    # Rating adjustment
-    if rating >= 4.5:
-        review_mult *= 1.03
-    elif rating < 3.5 and rating > 0:
-        review_mult *= 0.90  # poor ratings reduce repeat purchases
-
-    # ── Seasonal forecasting ─────────────────────────────────────────────────
-    now = datetime.now()
-    current_month = now.month
-
-    months = []
-    for i in range(1, 4):
-        month_num    = ((current_month - 1 + i) % 12) + 1
-        season_mult  = _SEASONALITY[month_num]
-        month_units  = int(base_units * trend_multiplier * review_mult * season_mult)
-        month_units  = max(1, month_units)
-        month_rev    = round(month_units * price, 2) if price > 0 else None
-
-        months.append({
-            "month":       _month_name(month_num),
-            "month_num":   month_num,
-            "units":       month_units,
-            "revenue":     month_rev,
-            "seasonal_factor": round(season_mult, 2),
-            "is_peak":     season_mult >= 1.2,
-        })
-
-    # ── Current month baseline ───────────────────────────────────────────────
-    current_season_mult = _SEASONALITY[current_month]
-    current_units = int(base_units * review_mult * current_season_mult)
-
-    # ── Annual projection ────────────────────────────────────────────────────
-    annual_units = int(base_units * review_mult * trend_multiplier * 12 *
-                       (sum(_SEASONALITY.values()) / 12))
-    annual_rev   = round(annual_units * price, 2) if price > 0 else None
-
-    # ── Peak season identification ───────────────────────────────────────────
-    peak_months = [m for m, s in _SEASONALITY.items() if s >= 1.1]
-    peak_names  = [_month_name(m) for m in peak_months]
-
-    # ── Confidence ───────────────────────────────────────────────────────────
-    confidence = trend_confidence
-    if price > 0: confidence += 5
-    if review_count > 50: confidence += 8
-    confidence = min(90, confidence)
-
-    # ── Insight ──────────────────────────────────────────────────────────────
-    if trend_description == "growing":
-        insight = f"Demand is trending upward. BSR has been improving — consider stocking up before peak season."
-    elif trend_description == "declining":
-        insight = f"Demand is declining. Reduce inventory risk by ordering conservatively."
-    else:
-        insight = f"Demand is stable. Focus on peak months ({', '.join(peak_names[:3])}) for maximum revenue."
-
-    result = {
-        "current_monthly_units": current_units,
-        "base_bsr_units":        base_units,
-        "trend":                 trend_description,
-        "trend_multiplier":      round(trend_multiplier, 3),
-        "forecast":              months,
-        "annual_projection": {
-            "units":   annual_units,
-            "revenue": annual_rev,
-        },
-        "peak_months":   peak_names,
-        "confidence":    confidence,
-        "insight":       insight,
-        "engine":        "heuristic",
-        "model":         "bsr-seasonal",
-        "model_inputs": {
-            "bsr":          bsr,
-            "review_count": review_count,
-            "rating":       rating,
-            "price":        price,
-        },
-    }
-
-    try:
-        from app.services.ml.sklearn_engine import get_engine
-        engine = get_engine()
-        if engine:
-            ml = engine.predict_demand(bsr, current_units, rating, review_count, price)
-            ml_units = ml["next_month_units"]
-            scale = ml_units / max(current_units, 1)
-            result["trend"] = ml["trend"]
-            result["trend_multiplier"] = round(scale, 3)
-            for m in result["forecast"]:
-                m["units"] = max(1, int(m["units"] * scale))
-                if price > 0:
-                    m["revenue"] = round(m["units"] * price, 2)
-            result["confidence"] = max(confidence, ml.get("confidence", 70))
-            result["engine"] = "sklearn+heuristic"
-            result["model"] = ml.get("model", "GradientBoostingRegressor")
-            result["model_version"] = ml.get("model_version")
-            result["insight"] = (
-                f"ML demand model forecasts ~{ml_units:,} units next month ({ml['trend']}). "
-                + insight
-            )
-    except Exception as e:
-        print(f"[demand_forecaster] sklearn blend failed: {e}")
-
-    return result
-
-
-def _month_name(n: int) -> str:
-    return ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"][n-1]
-
-
-def _empty_forecast():
-    return {
-        "current_monthly_units": 0,
-        "base_bsr_units":        0,
-        "trend":                 "unknown",
-        "trend_multiplier":      1.0,
-        "forecast":              [],
-        "annual_projection":     {"units": 0, "revenue": None},
-        "peak_months":           ["November", "December"],
-        "confidence":            20,
-        "insight":               "BSR data required for demand forecasting.",
-        "model_inputs":          {"bsr": None, "review_count": 0, "rating": 0, "price": 0},
+# app/services/ml/demand_forecaster.py
+# ─────────────────────────────────────────────────────────────────────────────
+# Demand Forecasting — predicts monthly unit sales for next 3 months.
+# Uses BSR → sales relationship (Jungle Scout / Helium 10 methodology)
+# combined with seasonal adjustments and trend momentum.
+# ─────────────────────────────────────────────────────────────────────────────
+
+import math
+from datetime import datetime
+from typing import Optional
+
+
+# Seasonal multipliers by month (empirical Amazon sales data)
+_SEASONALITY = {
+    1:  0.78,   # January  — post-holiday slump
+    2:  0.80,   # February
+    3:  0.88,   # March    — spring pickup
+    4:  0.90,   # April
+    5:  0.95,   # May      — Mother's Day boost
+    6:  0.88,   # June
+    7:  0.85,   # July     — Prime Day offset
+    8:  0.87,   # August   — back to school
+    9:  0.90,   # September
+    10: 1.05,   # October  — pre-holiday
+    11: 1.35,   # November — Black Friday / Cyber Monday
+    12: 1.45,   # December — peak holiday
+}
+
+# BSR to monthly units table (calibrated from Jungle Scout data)
+# Format: (bsr_min, bsr_max, base_monthly_units)
+_BSR_SALES_TABLE = [
+    (1,         100,        8500),
+    (100,       500,        4500),
+    (500,       1_000,      2800),
+    (1_000,     3_000,      1500),
+    (3_000,     5_000,      800),
+    (5_000,     10_000,     400),
+    (10_000,    25_000,     180),
+    (25_000,    50_000,     85),
+    (50_000,    100_000,    40),
+    (100_000,   250_000,    18),
+    (250_000,   500_000,    8),
+    (500_000,   1_000_000,  3),
+    (1_000_000, float("inf"), 1),
+]
+
+
+def _bsr_to_units(bsr: int) -> int:
+    for low, high, units in _BSR_SALES_TABLE:
+        if low <= bsr < high:
+            # Interpolate within the bracket
+            fraction = (bsr - low) / (high - low) if high != float("inf") else 0
+            # Units decrease as BSR increases within bracket
+            next_units = _BSR_SALES_TABLE[_BSR_SALES_TABLE.index((low, high, units)) + 1][2] \
+                         if high != float("inf") else 1
+            return max(1, int(units - fraction * (units - next_units)))
+    return 1
+
+
+def forecast_demand(
+    bsr: Optional[int],
+    category: str = "",
+    review_count: int = 0,
+    rating: float = 0.0,
+    price: float = 0.0,
+    history: Optional[list] = None,
+) -> dict:
+    """
+    Forecast monthly demand for the next 3 months.
+
+    Returns unit estimates, revenue estimates, trend direction,
+    and seasonal analysis.
+    """
+    if not bsr or bsr <= 0:
+        return _empty_forecast()
+
+    # ── Base sales from BSR ──────────────────────────────────────────────────
+    base_units = _bsr_to_units(bsr)
+
+    # ── Trend from BSR history ───────────────────────────────────────────────
+    trend_multiplier  = 1.0
+    trend_description = "stable"
+    trend_confidence  = 50
+
+    if history and len(history) >= 3:
+        bsr_values = [h.get("bsr") for h in history if h.get("bsr") and h["bsr"] > 0]
+        if len(bsr_values) >= 3:
+            # Lower BSR over time = improving sales = positive trend
+            recent  = bsr_values[:3]    # most recent 3
+            older   = bsr_values[-3:]   # oldest 3
+            avg_recent = sum(recent) / len(recent)
+            avg_older  = sum(older) / len(older)
+            if avg_older > 0:
+                change = (avg_older - avg_recent) / avg_older  # positive = BSR improving
+                trend_multiplier  = 1.0 + change * 0.3   # up to ±30% adjustment
+                trend_multiplier  = max(0.5, min(1.5, trend_multiplier))
+                trend_confidence  = 75
+                if change > 0.1:
+                    trend_description = "growing"
+                elif change < -0.1:
+                    trend_description = "declining"
+
+    # ── Review momentum multiplier ───────────────────────────────────────────
+    # High review count relative to BSR = loyal buyers = stable demand
+    review_mult = 1.0
+    if review_count > 1000:
+        review_mult = 1.08
+    elif review_count > 500:
+        review_mult = 1.04
+    elif review_count < 10:
+        review_mult = 0.92  # low review count = product is new/uncertain
+
+    # Rating adjustment
+    if rating >= 4.5:
+        review_mult *= 1.03
+    elif rating < 3.5 and rating > 0:
+        review_mult *= 0.90  # poor ratings reduce repeat purchases
+
+    # ── Seasonal forecasting ─────────────────────────────────────────────────
+    now = datetime.now()
+    current_month = now.month
+
+    months = []
+    for i in range(1, 4):
+        month_num    = ((current_month - 1 + i) % 12) + 1
+        season_mult  = _SEASONALITY[month_num]
+        month_units  = int(base_units * trend_multiplier * review_mult * season_mult)
+        month_units  = max(1, month_units)
+        month_rev    = round(month_units * price, 2) if price > 0 else None
+
+        months.append({
+            "month":       _month_name(month_num),
+            "month_num":   month_num,
+            "units":       month_units,
+            "revenue":     month_rev,
+            "seasonal_factor": round(season_mult, 2),
+            "is_peak":     season_mult >= 1.2,
+        })
+
+    # ── Current month baseline ───────────────────────────────────────────────
+    current_season_mult = _SEASONALITY[current_month]
+    current_units = int(base_units * review_mult * current_season_mult)
+
+    # ── Annual projection ────────────────────────────────────────────────────
+    annual_units = int(base_units * review_mult * trend_multiplier * 12 *
+                       (sum(_SEASONALITY.values()) / 12))
+    annual_rev   = round(annual_units * price, 2) if price > 0 else None
+
+    # ── Peak season identification ───────────────────────────────────────────
+    peak_months = [m for m, s in _SEASONALITY.items() if s >= 1.1]
+    peak_names  = [_month_name(m) for m in peak_months]
+
+    # ── Confidence ───────────────────────────────────────────────────────────
+    confidence = trend_confidence
+    if price > 0: confidence += 5
+    if review_count > 50: confidence += 8
+    confidence = min(90, confidence)
+
+    # ── Insight ──────────────────────────────────────────────────────────────
+    if trend_description == "growing":
+        insight = f"Demand is trending upward. BSR has been improving — consider stocking up before peak season."
+    elif trend_description == "declining":
+        insight = f"Demand is declining. Reduce inventory risk by ordering conservatively."
+    else:
+        insight = f"Demand is stable. Focus on peak months ({', '.join(peak_names[:3])}) for maximum revenue."
+
+    result = {
+        "current_monthly_units": current_units,
+        "base_bsr_units":        base_units,
+        "trend":                 trend_description,
+        "trend_multiplier":      round(trend_multiplier, 3),
+        "forecast":              months,
+        "annual_projection": {
+            "units":   annual_units,
+            "revenue": annual_rev,
+        },
+        "peak_months":   peak_names,
+        "confidence":    confidence,
+        "insight":       insight,
+        "engine":        "heuristic",
+        "model":         "bsr-seasonal",
+        "model_inputs": {
+            "bsr":          bsr,
+            "review_count": review_count,
+            "rating":       rating,
+            "price":        price,
+        },
+    }
+
+    try:
+        from app.services.ml.sklearn_engine import get_engine
+        engine = get_engine()
+        if engine:
+            ml = engine.predict_demand(bsr, current_units, rating, review_count, price)
+            ml_units = ml["next_month_units"]
+            scale = ml_units / max(current_units, 1)
+            result["trend"] = ml["trend"]
+            result["trend_multiplier"] = round(scale, 3)
+            for m in result["forecast"]:
+                m["units"] = max(1, int(m["units"] * scale))
+                if price > 0:
+                    m["revenue"] = round(m["units"] * price, 2)
+            result["confidence"] = max(confidence, ml.get("confidence", 70))
+            result["engine"] = "sklearn+heuristic"
+            result["model"] = ml.get("model", "GradientBoostingRegressor")
+            result["model_version"] = ml.get("model_version")
+            result["insight"] = (
+                f"ML demand model forecasts ~{ml_units:,} units next month ({ml['trend']}). "
+                + insight
+            )
+    except Exception as e:
+        print(f"[demand_forecaster] sklearn blend failed: {e}")
+
+    return result
+
+
+def _month_name(n: int) -> str:
+    return ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"][n-1]
+
+
+def _empty_forecast():
+    return {
+        "current_monthly_units": 0,
+        "base_bsr_units":        0,
+        "trend":                 "unknown",
+        "trend_multiplier":      1.0,
+        "forecast":              [],
+        "annual_projection":     {"units": 0, "revenue": None},
+        "peak_months":           ["November", "December"],
+        "confidence":            20,
+        "insight":               "BSR data required for demand forecasting.",
+        "model_inputs":          {"bsr": None, "review_count": 0, "rating": 0, "price": 0},
     }

app/services/ml/fake_review_detector.py

@@ -1,287 +1,287 @@
-# app/services/ml/fake_review_detector.py
-# ─────────────────────────────────────────────────────────────────────────────
-# Fake Review Detection using statistical pattern analysis.
-# No external ML library needed — uses pure math on review patterns.
-#
-# Academic basis: Ott et al. (2011) "Finding deceptive opinion spam"
-# Signals used:
-#   1. Rating distribution — real products follow bell curve; fake ones skew 5★
-#   2. Review velocity — sudden spike = bulk fake reviews
-#   3. Verified purchase ratio — low verified% is a red flag
-#   4. Rating vs text sentiment gap — 5★ but mediocre language
-#   5. Review count vs BSR correlation — mismatch signals manipulation
-# ─────────────────────────────────────────────────────────────────────────────
-
-import math
-from typing import Optional
-
-
-def detect_fake_reviews(
-    review_count: int,
-    rating: float,
-    bsr: Optional[int],
-    monthly_sales: Optional[int],
-    seller_count: int = 1,
-    is_fba: bool = False,
-) -> dict:
-    """
-    Analyse product signals and return fake review risk assessment.
-
-    Returns a dict with:
-        risk_score     : 0–100  (higher = more suspicious)
-        risk_level     : "low" | "medium" | "high" | "very_high"
-        confidence     : 0–100  (how confident we are in the assessment)
-        signals        : list of detected signal dicts
-        verdict        : human-readable summary string
-        trust_score    : 0–100  (inverse of risk — for display)
-        recommendation : action string
-    """
-    signals = []
-    risk_points = 0
-    max_points = 0
-
-    # ── Signal 1: Rating distribution suspicion ──────────────────────────────
-    # Products with perfect or near-perfect ratings are suspicious,
-    # especially with many reviews (hard to maintain naturally).
-    max_points += 25
-    if rating >= 4.9 and review_count > 50:
-        pts = 25
-        signals.append({
-            "name":        "Near-perfect rating",
-            "description": f"{rating}★ across {review_count:,} reviews is statistically unusual for real products",
-            "severity":    "high",
-            "icon":        "star",
-        })
-    elif rating >= 4.8 and review_count > 200:
-        pts = 18
-        signals.append({
-            "name":        "Suspiciously high rating",
-            "description": f"{rating}★ across {review_count:,} reviews — genuine products rarely sustain this",
-            "severity":    "medium",
-            "icon":        "star",
-        })
-    elif rating < 3.5 and review_count > 100:
-        # Very low rating with many reviews can also mean bought reviews that backfired
-        pts = 10
-        signals.append({
-            "name":        "Low rating with high review count",
-            "description": "Many reviews but poor rating — possible failed review manipulation",
-            "severity":    "low",
-            "icon":        "alert",
-        })
-    else:
-        pts = 0
-    risk_points += pts
-
-    # ── Signal 2: Review count vs BSR mismatch ────────────────────────────────
-    # If BSR is high (poor seller) but review count is large, something is off.
-    # A product with BSR 500,000 shouldn't have 5,000 reviews.
-    max_points += 25
-    if bsr and bsr > 0:
-        # Expected reviews for this BSR using empirical Amazon data:
-        # BSR 1-1000 → ~10,000+ reviews normal
-        # BSR 1000-10000 → ~500-5000 reviews normal
-        # BSR 10000-100000 → ~50-500 reviews normal
-        # BSR 100000+ → <50 reviews normal
-        if bsr < 1_000:
-            expected_max = 50_000
-        elif bsr < 10_000:
-            expected_max = 5_000
-        elif bsr < 100_000:
-            expected_max = 500
-        elif bsr < 500_000:
-            expected_max = 100
-        else:
-            expected_max = 30
-
-        ratio = review_count / expected_max if expected_max > 0 else 1.0
-
-        if ratio > 5.0:
-            pts = 25
-            signals.append({
-                "name":        "Review count vs sales rank mismatch",
-                "description": f"BSR #{bsr:,} implies low sales but {review_count:,} reviews — {ratio:.0f}× more than expected",
-                "severity":    "high",
-                "icon":        "chart-bar",
-            })
-        elif ratio > 2.5:
-            pts = 15
-            signals.append({
-                "name":        "Elevated review-to-rank ratio",
-                "description": f"Review count is {ratio:.0f}× higher than expected for BSR #{bsr:,}",
-                "severity":    "medium",
-                "icon":        "chart-bar",
-            })
-        else:
-            pts = 0
-    else:
-        pts = 0
-    risk_points += pts
-
-    # ── Signal 3: Review-to-sales conversion anomaly ─────────────────────────
-    # Normally ~2-5% of buyers leave reviews on Amazon.
-    # If reviews >> estimated buyers, manipulation is likely.
-    max_points += 20
-    if monthly_sales and monthly_sales > 0:
-        # Estimate total lifetime sales (rough: product has been live ~12 months avg)
-        estimated_total_buyers = monthly_sales * 12
-        natural_review_rate    = 0.04  # 4% of buyers review
-        expected_reviews       = estimated_total_buyers * natural_review_rate
-        if expected_reviews > 0:
-            review_ratio = review_count / expected_reviews
-            if review_ratio > 4.0:
-                pts = 20
-                signals.append({
-                    "name":        "Abnormal review conversion rate",
-                    "description": f"Review rate is {review_ratio:.0f}× above Amazon's natural 4% — suggests purchased reviews",
-                    "severity":    "high",
-                    "icon":        "users",
-                })
-            elif review_ratio > 2.0:
-                pts = 10
-                signals.append({
-                    "name":        "Above-average review rate",
-                    "description": f"Review count is {review_ratio:.0f}× what organic sales would produce",
-                    "severity":    "medium",
-                    "icon":        "users",
-                })
-            else:
-                pts = 0
-        else:
-            pts = 0
-    else:
-        pts = 0
-    risk_points += pts
-
-    # ── Signal 4: Seller pattern risk ────────────────────────────────────────
-    # Single seller + FBA + suspiciously high rating = common fake review setup
-    max_points += 15
-    if seller_count == 1 and rating >= 4.7 and review_count > 100:
-        pts = 15
-        signals.append({
-            "name":        "Monopoly seller with high rating",
-            "description": "Single seller controls buy box and maintains very high rating — common in review farm operations",
-            "severity":    "medium",
-            "icon":        "building-store",
-        })
-    elif seller_count <= 2 and rating >= 4.8:
-        pts = 8
-        signals.append({
-            "name":        "Limited competition with high rating",
-            "description": "Very few sellers with near-perfect rating — lower accountability for review authenticity",
-            "severity":    "low",
-            "icon":        "building-store",
-        })
-    else:
-        pts = 0
-    risk_points += pts
-
-    # ── Signal 5: Review count cluster check ─────────────────────────────────
-    # Certain review counts are suspicious (round numbers like exactly 1000, 2000
-    # or very specific patterns from bulk review services)
-    max_points += 15
-    suspicious_counts = [100, 200, 500, 1000, 1500, 2000, 2500, 3000, 5000]
-    if any(abs(review_count - sc) <= 2 for sc in suspicious_counts) and review_count > 50:
-        pts = 10
-        signals.append({
-            "name":        "Suspiciously round review count",
-            "description": f"{review_count} reviews — round numbers sometimes indicate bulk review purchases that stopped at a target",
-            "severity":    "low",
-            "icon":        "hash",
-        })
-    else:
-        pts = 0
-    risk_points += pts
-
-    # ── Positive trust signals (reduce risk) ─────────────────────────────────
-    trust_signals = []
-
-    if rating >= 3.5 and rating <= 4.4 and review_count > 20:
-        trust_signals.append("Realistic rating range — neither perfect nor manipulated downward")
-        risk_points = max(0, risk_points - 5)
-
-    if is_fba and seller_count > 3:
-        trust_signals.append("Multiple FBA sellers — competitive market reduces manipulation incentive")
-        risk_points = max(0, risk_points - 5)
-
-    if bsr and bsr < 5000 and review_count > 100:
-        trust_signals.append("Strong BSR supports high review count — organic success likely")
-        risk_points = max(0, risk_points - 8)
-
-    # ── Calculate final scores ────────────────────────────────────────────────
-    risk_score = min(100, int((risk_points / max_points) * 100)) if max_points > 0 else 0
-
-    # Confidence: higher when we have more data points
-    data_richness = sum([
-        1 if review_count > 0 else 0,
-        1 if rating > 0 else 0,
-        1 if bsr and bsr > 0 else 0,
-        1 if monthly_sales and monthly_sales > 0 else 0,
-    ])
-    confidence = int((data_richness / 4) * 85) + 10  # 10–95%
-
-    # Risk level thresholds
-    if risk_score >= 65:
-        risk_level = "very_high"
-        verdict = "High probability of fake reviews — exercise extreme caution before investing"
-        recommendation = "Do not source this product. The review count and rating pattern strongly suggests manufactured social proof."
-    elif risk_score >= 45:
-        risk_level = "high"
-        verdict = "Several suspicious patterns detected — reviews may be partially manipulated"
-        recommendation = "Investigate further. Check review dates for sudden spikes and read 1★ and 3★ reviews carefully."
-    elif risk_score >= 25:
-        risk_level = "medium"
-        verdict = "Some anomalies present — reviews are likely mostly genuine with possible padding"
-        recommendation = "Proceed with caution. Read recent reviews and check for duplicate review text."
-    else:
-        risk_level = "low"
-        verdict = "Review profile appears organic — no major red flags detected"
-        recommendation = "Reviews appear trustworthy. Standard due diligence still recommended."
-
-    trust_score = 100 - risk_score
-
-    result = {
-        "risk_score":      risk_score,
-        "risk_level":      risk_level,
-        "trust_score":     trust_score,
-        "confidence":      confidence,
-        "verdict":         verdict,
-        "recommendation":  recommendation,
-        "signals":         signals,
-        "trust_signals":   trust_signals,
-        "engine":          "heuristic",
-        "model":           "statistical-signals",
-        "stats": {
-            "review_count":  review_count,
-            "rating":        rating,
-            "bsr":           bsr,
-            "monthly_sales": monthly_sales,
-        },
-    }
-
-    try:
-        from app.services.ml.sklearn_engine import get_engine
-        engine = get_engine()
-        if engine:
-            ml = engine.predict_fake_review_risk(
-                review_count, rating, bsr, monthly_sales, seller_count
-            )
-            blended = int(min(100, max(0, ml["risk_score"] * 0.65 + risk_score * 0.35)))
-            result["risk_score"] = blended
-            result["trust_score"] = 100 - blended
-            result["confidence"] = max(confidence, ml.get("confidence", 70))
-            result["engine"] = "sklearn+heuristic"
-            result["model"] = ml.get("model", "RandomForestClassifier")
-            result["model_version"] = ml.get("model_version")
-            if blended >= 65:
-                result["risk_level"] = "very_high"
-            elif blended >= 45:
-                result["risk_level"] = "high"
-            elif blended >= 25:
-                result["risk_level"] = "medium"
-            else:
-                result["risk_level"] = "low"
-    except Exception as e:
-        print(f"[fake_review_detector] sklearn blend failed: {e}")
-
+# app/services/ml/fake_review_detector.py
+# ─────────────────────────────────────────────────────────────────────────────
+# Fake Review Detection using statistical pattern analysis.
+# No external ML library needed — uses pure math on review patterns.
+#
+# Academic basis: Ott et al. (2011) "Finding deceptive opinion spam"
+# Signals used:
+#   1. Rating distribution — real products follow bell curve; fake ones skew 5★
+#   2. Review velocity — sudden spike = bulk fake reviews
+#   3. Verified purchase ratio — low verified% is a red flag
+#   4. Rating vs text sentiment gap — 5★ but mediocre language
+#   5. Review count vs BSR correlation — mismatch signals manipulation
+# ─────────────────────────────────────────────────────────────────────────────
+
+import math
+from typing import Optional
+
+
+def detect_fake_reviews(
+    review_count: int,
+    rating: float,
+    bsr: Optional[int],
+    monthly_sales: Optional[int],
+    seller_count: int = 1,
+    is_fba: bool = False,
+) -> dict:
+    """
+    Analyse product signals and return fake review risk assessment.
+
+    Returns a dict with:
+        risk_score     : 0–100  (higher = more suspicious)
+        risk_level     : "low" | "medium" | "high" | "very_high"
+        confidence     : 0–100  (how confident we are in the assessment)
+        signals        : list of detected signal dicts
+        verdict        : human-readable summary string
+        trust_score    : 0–100  (inverse of risk — for display)
+        recommendation : action string
+    """
+    signals = []
+    risk_points = 0
+    max_points = 0
+
+    # ── Signal 1: Rating distribution suspicion ──────────────────────────────
+    # Products with perfect or near-perfect ratings are suspicious,
+    # especially with many reviews (hard to maintain naturally).
+    max_points += 25
+    if rating >= 4.9 and review_count > 50:
+        pts = 25
+        signals.append({
+            "name":        "Near-perfect rating",
+            "description": f"{rating}★ across {review_count:,} reviews is statistically unusual for real products",
+            "severity":    "high",
+            "icon":        "star",
+        })
+    elif rating >= 4.8 and review_count > 200:
+        pts = 18
+        signals.append({
+            "name":        "Suspiciously high rating",
+            "description": f"{rating}★ across {review_count:,} reviews — genuine products rarely sustain this",
+            "severity":    "medium",
+            "icon":        "star",
+        })
+    elif rating < 3.5 and review_count > 100:
+        # Very low rating with many reviews can also mean bought reviews that backfired
+        pts = 10
+        signals.append({
+            "name":        "Low rating with high review count",
+            "description": "Many reviews but poor rating — possible failed review manipulation",
+            "severity":    "low",
+            "icon":        "alert",
+        })
+    else:
+        pts = 0
+    risk_points += pts
+
+    # ── Signal 2: Review count vs BSR mismatch ────────────────────────────────
+    # If BSR is high (poor seller) but review count is large, something is off.
+    # A product with BSR 500,000 shouldn't have 5,000 reviews.
+    max_points += 25
+    if bsr and bsr > 0:
+        # Expected reviews for this BSR using empirical Amazon data:
+        # BSR 1-1000 → ~10,000+ reviews normal
+        # BSR 1000-10000 → ~500-5000 reviews normal
+        # BSR 10000-100000 → ~50-500 reviews normal
+        # BSR 100000+ → <50 reviews normal
+        if bsr < 1_000:
+            expected_max = 50_000
+        elif bsr < 10_000:
+            expected_max = 5_000
+        elif bsr < 100_000:
+            expected_max = 500
+        elif bsr < 500_000:
+            expected_max = 100
+        else:
+            expected_max = 30
+
+        ratio = review_count / expected_max if expected_max > 0 else 1.0
+
+        if ratio > 5.0:
+            pts = 25
+            signals.append({
+                "name":        "Review count vs sales rank mismatch",
+                "description": f"BSR #{bsr:,} implies low sales but {review_count:,} reviews — {ratio:.0f}× more than expected",
+                "severity":    "high",
+                "icon":        "chart-bar",
+            })
+        elif ratio > 2.5:
+            pts = 15
+            signals.append({
+                "name":        "Elevated review-to-rank ratio",
+                "description": f"Review count is {ratio:.0f}× higher than expected for BSR #{bsr:,}",
+                "severity":    "medium",
+                "icon":        "chart-bar",
+            })
+        else:
+            pts = 0
+    else:
+        pts = 0
+    risk_points += pts
+
+    # ── Signal 3: Review-to-sales conversion anomaly ─────────────────────────
+    # Normally ~2-5% of buyers leave reviews on Amazon.
+    # If reviews >> estimated buyers, manipulation is likely.
+    max_points += 20
+    if monthly_sales and monthly_sales > 0:
+        # Estimate total lifetime sales (rough: product has been live ~12 months avg)
+        estimated_total_buyers = monthly_sales * 12
+        natural_review_rate    = 0.04  # 4% of buyers review
+        expected_reviews       = estimated_total_buyers * natural_review_rate
+        if expected_reviews > 0:
+            review_ratio = review_count / expected_reviews
+            if review_ratio > 4.0:
+                pts = 20
+                signals.append({
+                    "name":        "Abnormal review conversion rate",
+                    "description": f"Review rate is {review_ratio:.0f}× above Amazon's natural 4% — suggests purchased reviews",
+                    "severity":    "high",
+                    "icon":        "users",
+                })
+            elif review_ratio > 2.0:
+                pts = 10
+                signals.append({
+                    "name":        "Above-average review rate",
+                    "description": f"Review count is {review_ratio:.0f}× what organic sales would produce",
+                    "severity":    "medium",
+                    "icon":        "users",
+                })
+            else:
+                pts = 0
+        else:
+            pts = 0
+    else:
+        pts = 0
+    risk_points += pts
+
+    # ── Signal 4: Seller pattern risk ────────────────────────────────────────
+    # Single seller + FBA + suspiciously high rating = common fake review setup
+    max_points += 15
+    if seller_count == 1 and rating >= 4.7 and review_count > 100:
+        pts = 15
+        signals.append({
+            "name":        "Monopoly seller with high rating",
+            "description": "Single seller controls buy box and maintains very high rating — common in review farm operations",
+            "severity":    "medium",
+            "icon":        "building-store",
+        })
+    elif seller_count <= 2 and rating >= 4.8:
+        pts = 8
+        signals.append({
+            "name":        "Limited competition with high rating",
+            "description": "Very few sellers with near-perfect rating — lower accountability for review authenticity",
+            "severity":    "low",
+            "icon":        "building-store",
+        })
+    else:
+        pts = 0
+    risk_points += pts
+
+    # ── Signal 5: Review count cluster check ─────────────────────────────────
+    # Certain review counts are suspicious (round numbers like exactly 1000, 2000
+    # or very specific patterns from bulk review services)
+    max_points += 15
+    suspicious_counts = [100, 200, 500, 1000, 1500, 2000, 2500, 3000, 5000]
+    if any(abs(review_count - sc) <= 2 for sc in suspicious_counts) and review_count > 50:
+        pts = 10
+        signals.append({
+            "name":        "Suspiciously round review count",
+            "description": f"{review_count} reviews — round numbers sometimes indicate bulk review purchases that stopped at a target",
+            "severity":    "low",
+            "icon":        "hash",
+        })
+    else:
+        pts = 0
+    risk_points += pts
+
+    # ── Positive trust signals (reduce risk) ─────────────────────────────────
+    trust_signals = []
+
+    if rating >= 3.5 and rating <= 4.4 and review_count > 20:
+        trust_signals.append("Realistic rating range — neither perfect nor manipulated downward")
+        risk_points = max(0, risk_points - 5)
+
+    if is_fba and seller_count > 3:
+        trust_signals.append("Multiple FBA sellers — competitive market reduces manipulation incentive")
+        risk_points = max(0, risk_points - 5)
+
+    if bsr and bsr < 5000 and review_count > 100:
+        trust_signals.append("Strong BSR supports high review count — organic success likely")
+        risk_points = max(0, risk_points - 8)
+
+    # ── Calculate final scores ────────────────────────────────────────────────
+    risk_score = min(100, int((risk_points / max_points) * 100)) if max_points > 0 else 0
+
+    # Confidence: higher when we have more data points
+    data_richness = sum([
+        1 if review_count > 0 else 0,
+        1 if rating > 0 else 0,
+        1 if bsr and bsr > 0 else 0,
+        1 if monthly_sales and monthly_sales > 0 else 0,
+    ])
+    confidence = int((data_richness / 4) * 85) + 10  # 10–95%
+
+    # Risk level thresholds
+    if risk_score >= 65:
+        risk_level = "very_high"
+        verdict = "High probability of fake reviews — exercise extreme caution before investing"
+        recommendation = "Do not source this product. The review count and rating pattern strongly suggests manufactured social proof."
+    elif risk_score >= 45:
+        risk_level = "high"
+        verdict = "Several suspicious patterns detected — reviews may be partially manipulated"
+        recommendation = "Investigate further. Check review dates for sudden spikes and read 1★ and 3★ reviews carefully."
+    elif risk_score >= 25:
+        risk_level = "medium"
+        verdict = "Some anomalies present — reviews are likely mostly genuine with possible padding"
+        recommendation = "Proceed with caution. Read recent reviews and check for duplicate review text."
+    else:
+        risk_level = "low"
+        verdict = "Review profile appears organic — no major red flags detected"
+        recommendation = "Reviews appear trustworthy. Standard due diligence still recommended."
+
+    trust_score = 100 - risk_score
+
+    result = {
+        "risk_score":      risk_score,
+        "risk_level":      risk_level,
+        "trust_score":     trust_score,
+        "confidence":      confidence,
+        "verdict":         verdict,
+        "recommendation":  recommendation,
+        "signals":         signals,
+        "trust_signals":   trust_signals,
+        "engine":          "heuristic",
+        "model":           "statistical-signals",
+        "stats": {
+            "review_count":  review_count,
+            "rating":        rating,
+            "bsr":           bsr,
+            "monthly_sales": monthly_sales,
+        },
+    }
+
+    try:
+        from app.services.ml.sklearn_engine import get_engine
+        engine = get_engine()
+        if engine:
+            ml = engine.predict_fake_review_risk(
+                review_count, rating, bsr, monthly_sales, seller_count
+            )
+            blended = int(min(100, max(0, ml["risk_score"] * 0.65 + risk_score * 0.35)))
+            result["risk_score"] = blended
+            result["trust_score"] = 100 - blended
+            result["confidence"] = max(confidence, ml.get("confidence", 70))
+            result["engine"] = "sklearn+heuristic"
+            result["model"] = ml.get("model", "RandomForestClassifier")
+            result["model_version"] = ml.get("model_version")
+            if blended >= 65:
+                result["risk_level"] = "very_high"
+            elif blended >= 45:
+                result["risk_level"] = "high"
+            elif blended >= 25:
+                result["risk_level"] = "medium"
+            else:
+                result["risk_level"] = "low"
+    except Exception as e:
+        print(f"[fake_review_detector] sklearn blend failed: {e}")
+
     return result

app/services/ml/ml_engine.py

@@ -1,509 +1,509 @@
-"""
-Rankora ML Engine
-4 ML Features:
-1. Fake Review Detector
-2. Price Prediction (Linear Regression)
-3. Demand Forecasting (Seasonality)
-4. Niche Scorer
-"""
-
-import math
-import random
-from typing import Optional
-from datetime import datetime, timezone
-
-
-# ═══════════════════════════════════════════════════════════════
-# 1. FAKE REVIEW DETECTOR
-# ═══════════════════════════════════════════════════════════════
-
-def detect_fake_reviews(
-    rating: float,
-    review_count: int,
-    rating_distribution: Optional[dict] = None,
-    monthly_sales_estimate: int = 100,
-    asin: str = ""
-) -> dict:
-    """
-    Detect suspicious review patterns using rule-based ML heuristics.
-    Returns a suspicion score 0-100 and detailed signals.
-    """
-    signals = []
-    suspicion_score = 0
-
-    # Signal 1: Perfect or near-perfect rating with many reviews
-    if rating >= 4.8 and review_count > 500:
-        suspicion_score += 20
-        signals.append({
-            "signal": "Suspiciously High Rating",
-            "detail": f"{rating}★ with {review_count:,} reviews — real products rarely maintain 4.8+ at scale",
-            "severity": "high",
-            "weight": 20
-        })
-    elif rating >= 4.9 and review_count > 100:
-        suspicion_score += 25
-        signals.append({
-            "signal": "Near-Perfect Rating",
-            "detail": f"{rating}★ is unusually high — may indicate review manipulation",
-            "severity": "high",
-            "weight": 25
-        })
-
-    # Signal 2: Review velocity vs sales ratio
-    # If reviews >> expected for sales level, reviews may be incentivized
-    expected_reviews = monthly_sales_estimate * 0.02  # ~2% of sales leave reviews
-    if review_count > 0 and monthly_sales_estimate > 0:
-        review_rate = review_count / max(monthly_sales_estimate * 6, 1)  # 6 months
-        if review_rate > 0.15:  # more than 15% of buyers reviewing is suspicious
-            suspicion_score += 20
-            signals.append({
-                "signal": "High Review Velocity",
-                "detail": f"Review rate ({review_rate:.1%}) is unusually high vs estimated sales — possible incentivized reviews",
-                "severity": "medium",
-                "weight": 20
-            })
-
-    # Signal 3: Very low review count but high BSR
-    # High sales rank but very few reviews = possibly review reset / new ASIN
-    if monthly_sales_estimate > 500 and review_count < 20:
-        suspicion_score += 15
-        signals.append({
-            "signal": "Sales/Review Mismatch",
-            "detail": f"High estimated sales ({monthly_sales_estimate:,}/mo) but only {review_count} reviews — possible review manipulation reset",
-            "severity": "medium",
-            "weight": 15
-        })
-
-    # Signal 4: Rating distribution analysis (if provided)
-    if rating_distribution:
-        five_star_pct = rating_distribution.get("5_star", 0)
-        one_star_pct  = rating_distribution.get("1_star", 0)
-        if five_star_pct > 85:
-            suspicion_score += 20
-            signals.append({
-                "signal": "Extreme 5-Star Concentration",
-                "detail": f"{five_star_pct}% five-star reviews — legitimate products rarely exceed 80%",
-                "severity": "high",
-                "weight": 20
-            })
-        if one_star_pct < 1 and review_count > 200:
-            suspicion_score += 10
-            signals.append({
-                "signal": "Missing Negative Reviews",
-                "detail": f"Only {one_star_pct}% 1-star reviews out of {review_count:,} — statistically unlikely for real products",
-                "severity": "medium",
-                "weight": 10
-            })
-
-    # Signal 5: Round number review counts often indicate manipulation
-    if review_count > 100:
-        str_count = str(review_count)
-        trailing_zeros = len(str_count) - len(str_count.rstrip("0"))
-        if trailing_zeros >= 2:
-            suspicion_score += 10
-            signals.append({
-                "signal": "Suspicious Review Count",
-                "detail": f"Round number ({review_count:,}) with trailing zeros — may indicate manipulated count",
-                "severity": "low",
-                "weight": 10
-            })
-
-    suspicion_score = min(suspicion_score, 100)
-
-    if suspicion_score >= 60:
-        verdict = "HIGH RISK — Likely Fake Reviews"
-        verdict_color = "#EF4444"
-        recommendation = "Avoid this product — high probability of review manipulation"
-    elif suspicion_score >= 35:
-        verdict = "MODERATE RISK — Suspicious Patterns"
-        verdict_color = "#F59E0B"
-        recommendation = "Investigate further before competing in this space"
-    elif suspicion_score >= 15:
-        verdict = "LOW RISK — Minor Concerns"
-        verdict_color = "#FB923C"
-        recommendation = "Reviews appear mostly genuine with minor anomalies"
-    else:
-        verdict = "AUTHENTIC — Reviews Appear Genuine"
-        verdict_color = "#10B981"
-        recommendation = "No significant red flags detected in review patterns"
-
-    return {
-        "suspicion_score": suspicion_score,
-        "verdict": verdict,
-        "verdict_color": verdict_color,
-        "recommendation": recommendation,
-        "signals": signals,
-        "signals_count": len(signals),
-        "is_suspicious": suspicion_score >= 35,
-        "analysis_basis": {
-            "rating": rating,
-            "review_count": review_count,
-            "monthly_sales_estimate": monthly_sales_estimate,
-        }
-    }
-
-
-# ═══════════════════════════════════════════════════════════════
-# 2. PRICE PREDICTION (Linear Regression)
-# ═══════════════════════════════════════════════════════════════
-
-def predict_price(
-    price_history: list,
-    days_ahead: int = 7
-) -> dict:
-    """
-    Predict future price using linear regression on price history.
-    price_history: list of {"price": float, "recorded_at": str}
-    """
-    if not price_history or len(price_history) < 3:
-        return {
-            "predicted_price": None,
-            "confidence": "low",
-            "trend": "insufficient_data",
-            "message": "Need at least 3 data points for prediction"
-        }
-
-    # Extract prices
-    prices = [float(p["price"]) for p in price_history if p.get("price")]
-    if len(prices) < 3:
-        return {"predicted_price": None, "confidence": "low", "trend": "insufficient_data"}
-
-    n = len(prices)
-    x = list(range(n))
-
-    # Linear regression: y = mx + b
-    sum_x  = sum(x)
-    sum_y  = sum(prices)
-    sum_xy = sum(x[i] * prices[i] for i in range(n))
-    sum_x2 = sum(xi ** 2 for xi in x)
-
-    denom = n * sum_x2 - sum_x ** 2
-    if denom == 0:
-        slope = 0
-    else:
-        slope = (n * sum_xy - sum_x * sum_y) / denom
-    intercept = (sum_y - slope * sum_x) / n
-
-    # Predict future price
-    future_x = n - 1 + days_ahead
-    predicted = round(intercept + slope * future_x, 2)
-    predicted = max(0.01, predicted)  # price can't be negative
-
-    # Calculate R² for confidence
-    y_mean = sum_y / n
-    ss_tot = sum((p - y_mean) ** 2 for p in prices)
-    ss_res = sum((prices[i] - (intercept + slope * x[i])) ** 2 for i in range(n))
-    r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0
-
-    # Determine trend
-    current_price = prices[-1]
-    price_change_pct = ((predicted - current_price) / current_price) * 100
-
-    if slope > 0.01:
-        trend = "rising"
-        trend_emoji = "📈"
-        trend_color = "#EF4444"
-    elif slope < -0.01:
-        trend = "falling"
-        trend_emoji = "📉"
-        trend_color = "#10B981"
-    else:
-        trend = "stable"
-        trend_emoji = "➡️"
-        trend_color = "#6B7280"
-
-    confidence = "high" if r2 > 0.7 else "medium" if r2 > 0.4 else "low"
-
-    # Price stats
-    min_price = min(prices)
-    max_price = max(prices)
-    avg_price = sum(prices) / len(prices)
-
-    return {
-        "predicted_price": predicted,
-        "current_price": current_price,
-        "price_change": round(predicted - current_price, 2),
-        "price_change_pct": round(price_change_pct, 1),
-        "trend": trend,
-        "trend_emoji": trend_emoji,
-        "trend_color": trend_color,
-        "confidence": confidence,
-        "r_squared": round(r2, 3),
-        "days_ahead": days_ahead,
-        "slope_per_day": round(slope, 4),
-        "price_stats": {
-            "min": round(min_price, 2),
-            "max": round(max_price, 2),
-            "avg": round(avg_price, 2),
-            "volatility": round((max_price - min_price) / avg_price * 100, 1)
-        },
-        "recommendation": (
-            f"Price expected to {'rise' if trend == 'rising' else 'fall' if trend == 'falling' else 'stay stable'} "
-            f"by {abs(price_change_pct):.1f}% over next {days_ahead} days"
-        )
-    }
-
-
-# ═══════════════════════════════════════════════════════════════
-# 3. DEMAND FORECASTING (Seasonality Detection)
-# ═══════════════════════════════════════════════════════════════
-
-def forecast_demand(
-    bsr_history: list,
-    category: str = "general",
-    current_month: Optional[int] = None
-) -> dict:
-    """
-    Forecast demand using BSR trends and seasonal patterns.
-    Lower BSR = higher demand.
-    """
-    if current_month is None:
-        current_month = datetime.now(timezone.utc).month
-
-    # Category seasonal multipliers (month 1-12)
-    seasonal_patterns = {
-        "electronics": [0.8, 0.7, 0.8, 0.9, 0.9, 0.8, 0.9, 0.9, 1.0, 1.0, 1.3, 1.4],
-        "home": [0.9, 0.8, 1.0, 1.1, 1.2, 1.1, 1.0, 0.9, 0.9, 1.0, 1.1, 1.0],
-        "toys": [0.7, 0.6, 0.7, 0.7, 0.8, 0.8, 0.9, 0.9, 1.0, 1.1, 1.3, 1.8],
-        "sports": [0.9, 0.9, 1.1, 1.2, 1.3, 1.3, 1.2, 1.1, 1.0, 0.9, 0.8, 0.8],
-        "kitchen": [0.9, 0.9, 1.0, 1.0, 1.0, 0.9, 0.9, 0.9, 0.9, 1.0, 1.1, 1.2],
-        "general":  [1.0, 0.9, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.1, 1.2],
-    }
-
-    # Match category
-    cat_key = "general"
-    category_lower = category.lower()
-    for key in seasonal_patterns:
-        if key in category_lower:
-            cat_key = key
-            break
-
-    pattern = seasonal_patterns[cat_key]
-    current_multiplier = pattern[current_month - 1]
-    next_month = (current_month % 12)
-    next_multiplier = pattern[next_month]
-
-    # BSR trend analysis
-    bsr_trend = "stable"
-    bsr_change_pct = 0
-    demand_trend = "stable"
-
-    if bsr_history and len(bsr_history) >= 3:
-        bsr_values = [h.get("bsr") for h in bsr_history if h.get("bsr")]
-        if len(bsr_values) >= 3:
-            old_bsr = sum(bsr_values[:3]) / 3
-            new_bsr = sum(bsr_values[-3:]) / 3
-            bsr_change_pct = ((new_bsr - old_bsr) / old_bsr) * 100
-
-            if bsr_change_pct < -10:
-                bsr_trend = "improving"  # BSR going down = demand going up
-                demand_trend = "increasing"
-            elif bsr_change_pct > 10:
-                bsr_trend = "declining"
-                demand_trend = "decreasing"
-            else:
-                bsr_trend = "stable"
-                demand_trend = "stable"
-
-    # Seasonal score for each month
-    months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]
-    monthly_forecast = []
-    for i, mult in enumerate(pattern):
-        monthly_forecast.append({
-            "month": months[i],
-            "demand_index": round(mult * 100),
-            "is_peak": mult >= 1.2,
-            "is_low": mult <= 0.8,
-        })
-
-    peak_months = [months[i] for i, m in enumerate(pattern) if m >= 1.2]
-    low_months  = [months[i] for i, m in enumerate(pattern) if m <= 0.8]
-
-    if current_multiplier >= 1.2:
-        season_status = "PEAK SEASON"
-        season_color = "#10B981"
-        season_advice = "Great time to sell — high demand period"
-    elif current_multiplier >= 1.0:
-        season_status = "NORMAL SEASON"
-        season_color = "#3B82F6"
-        season_advice = "Average demand — maintain stock levels"
-    elif current_multiplier >= 0.85:
-        season_status = "SLOW SEASON"
-        season_color = "#F59E0B"
-        season_advice = "Reduce inventory — lower demand period"
-    else:
-        season_status = "OFF SEASON"
-        season_color = "#EF4444"
-        season_advice = "Avoid heavy stock — very low demand"
-
-    demand_change_next = round((next_multiplier - current_multiplier) / current_multiplier * 100, 1)
-
-    return {
-        "current_season": season_status,
-        "season_color": season_color,
-        "season_advice": season_advice,
-        "current_demand_index": round(current_multiplier * 100),
-        "next_month_demand_index": round(next_multiplier * 100),
-        "demand_change_next_month": demand_change_next,
-        "demand_trend": demand_trend,
-        "bsr_trend": bsr_trend,
-        "bsr_change_pct": round(bsr_change_pct, 1),
-        "category": cat_key,
-        "peak_months": peak_months,
-        "low_months": low_months,
-        "monthly_forecast": monthly_forecast,
-        "recommendation": (
-            f"{season_status}: {season_advice}. "
-            f"Next month demand expected to {'increase' if demand_change_next > 5 else 'decrease' if demand_change_next < -5 else 'stay similar'} "
-            f"by {abs(demand_change_next):.0f}%."
-        )
-    }
-
-
-# ═══════════════════════════════════════════════════════════════
-# 4. NICHE SCORER
-# ═══════════════════════════════════════════════════════════════
-
-def score_niche(
-    keyword: str,
-    products: list,  # list of {bsr, price, reviews, rating}
-    category: str = "general"
-) -> dict:
-    """
-    Score an entire niche/keyword based on multiple product data points.
-    Returns opportunity score 0-100 and detailed breakdown.
-    """
-    if not products:
-        return {"error": "No products provided for niche analysis"}
-
-    prices   = [p.get("price", 0)   for p in products if p.get("price")]
-    bsrs     = [p.get("bsr", 0)     for p in products if p.get("bsr")]
-    reviews  = [p.get("reviews", 0) for p in products if p.get("reviews") is not None]
-    ratings  = [p.get("rating", 0)  for p in products if p.get("rating")]
-
-    def avg(lst): return sum(lst) / len(lst) if lst else 0
-    def median(lst):
-        s = sorted(lst)
-        n = len(s)
-        return (s[n//2] + s[n//2-1]) / 2 if n % 2 == 0 else s[n//2]
-
-    avg_price   = avg(prices)
-    avg_bsr     = avg(bsrs)
-    avg_reviews = avg(reviews)
-    avg_rating  = avg(ratings)
-    med_reviews = median(reviews) if reviews else 0
-
-    scores = {}
-
-    # 1. Demand Score (based on BSR)
-    if avg_bsr < 1000:
-        scores["demand"] = 95
-    elif avg_bsr < 5000:
-        scores["demand"] = 80
-    elif avg_bsr < 20000:
-        scores["demand"] = 65
-    elif avg_bsr < 100000:
-        scores["demand"] = 45
-    else:
-        scores["demand"] = 20
-
-    # 2. Competition Score (lower reviews = easier to compete)
-    if avg_reviews < 50:
-        scores["competition"] = 90
-    elif avg_reviews < 200:
-        scores["competition"] = 75
-    elif avg_reviews < 500:
-        scores["competition"] = 55
-    elif avg_reviews < 2000:
-        scores["competition"] = 35
-    else:
-        scores["competition"] = 15
-
-    # 3. Profitability Score (based on price)
-    if avg_price >= 25 and avg_price <= 70:
-        scores["profitability"] = 85
-    elif avg_price >= 15 and avg_price < 25:
-        scores["profitability"] = 65
-    elif avg_price >= 70 and avg_price <= 150:
-        scores["profitability"] = 70
-    elif avg_price > 150:
-        scores["profitability"] = 50
-    else:
-        scores["profitability"] = 35
-
-    # 4. Quality Gap Score (lower ratings = easier to beat with better product)
-    if avg_rating < 3.8:
-        scores["quality_gap"] = 90
-    elif avg_rating < 4.2:
-        scores["quality_gap"] = 70
-    elif avg_rating < 4.5:
-        scores["quality_gap"] = 50
-    else:
-        scores["quality_gap"] = 25
-
-    # 5. Market Size Score
-    n = len(products)
-    if n >= 10:
-        scores["market_size"] = 80
-    elif n >= 5:
-        scores["market_size"] = 60
-    else:
-        scores["market_size"] = 40
-
-    # Weighted total
-    total = (
-        scores["demand"]       * 0.30 +
-        scores["competition"]  * 0.30 +
-        scores["profitability"]* 0.20 +
-        scores["quality_gap"]  * 0.15 +
-        scores["market_size"]  * 0.05
-    )
-    total = round(total)
-
-    if total >= 70:
-        verdict = "Excellent Niche"
-        verdict_color = "#10B981"
-        recommendation = "Strong opportunity — low competition, good demand, profitable price range"
-    elif total >= 55:
-        verdict = "Good Niche"
-        verdict_color = "#3B82F6"
-        recommendation = "Decent opportunity — worth pursuing with right differentiation"
-    elif total >= 40:
-        verdict = "Moderate Niche"
-        verdict_color = "#F59E0B"
-        recommendation = "Average opportunity — possible but competitive, needs strong USP"
-    else:
-        verdict = "Tough Niche"
-        verdict_color = "#EF4444"
-        recommendation = "Difficult market — high competition or low margins"
-
-    # Review gaps — products with < 100 reviews in a market with demand
-    low_review_products = [p for p in products if (p.get("reviews") or 0) < 100 and (p.get("bsr") or 999999) < 50000]
-
-    return {
-        "keyword": keyword,
-        "niche_score": total,
-        "verdict": verdict,
-        "verdict_color": verdict_color,
-        "recommendation": recommendation,
-        "scores": {
-            "demand":        {"score": scores["demand"],        "label": "Market Demand",     "weight": "30%"},
-            "competition":   {"score": scores["competition"],   "label": "Competition Level", "weight": "30%"},
-            "profitability": {"score": scores["profitability"], "label": "Profitability",     "weight": "20%"},
-            "quality_gap":   {"score": scores["quality_gap"],  "label": "Quality Gap",       "weight": "15%"},
-            "market_size":   {"score": scores["market_size"],  "label": "Market Size",       "weight": "5%"},
-        },
-        "market_stats": {
-            "products_analyzed": len(products),
-            "avg_price": round(avg_price, 2),
-            "avg_bsr": round(avg_bsr),
-            "avg_reviews": round(avg_reviews),
-            "avg_rating": round(avg_rating, 1),
-            "median_reviews": round(med_reviews),
-        },
-        "opportunities": {
-            "low_review_opportunities": len(low_review_products),
-            "easy_entry_products": [p.get("asin", "") for p in low_review_products[:3]],
-            "price_gap": round(max(prices) - min(prices), 2) if prices else 0,
-        }
-    }
+"""
+Rankora ML Engine
+4 ML Features:
+1. Fake Review Detector
+2. Price Prediction (Linear Regression)
+3. Demand Forecasting (Seasonality)
+4. Niche Scorer
+"""
+
+import math
+import random
+from typing import Optional
+from datetime import datetime, timezone
+
+
+# ═════════════════════════════════════════════��═════════════════
+# 1. FAKE REVIEW DETECTOR
+# ═══════════════════════════════════════════════════════════════
+
+def detect_fake_reviews(
+    rating: float,
+    review_count: int,
+    rating_distribution: Optional[dict] = None,
+    monthly_sales_estimate: int = 100,
+    asin: str = ""
+) -> dict:
+    """
+    Detect suspicious review patterns using rule-based ML heuristics.
+    Returns a suspicion score 0-100 and detailed signals.
+    """
+    signals = []
+    suspicion_score = 0
+
+    # Signal 1: Perfect or near-perfect rating with many reviews
+    if rating >= 4.8 and review_count > 500:
+        suspicion_score += 20
+        signals.append({
+            "signal": "Suspiciously High Rating",
+            "detail": f"{rating}★ with {review_count:,} reviews — real products rarely maintain 4.8+ at scale",
+            "severity": "high",
+            "weight": 20
+        })
+    elif rating >= 4.9 and review_count > 100:
+        suspicion_score += 25
+        signals.append({
+            "signal": "Near-Perfect Rating",
+            "detail": f"{rating}★ is unusually high — may indicate review manipulation",
+            "severity": "high",
+            "weight": 25
+        })
+
+    # Signal 2: Review velocity vs sales ratio
+    # If reviews >> expected for sales level, reviews may be incentivized
+    expected_reviews = monthly_sales_estimate * 0.02  # ~2% of sales leave reviews
+    if review_count > 0 and monthly_sales_estimate > 0:
+        review_rate = review_count / max(monthly_sales_estimate * 6, 1)  # 6 months
+        if review_rate > 0.15:  # more than 15% of buyers reviewing is suspicious
+            suspicion_score += 20
+            signals.append({
+                "signal": "High Review Velocity",
+                "detail": f"Review rate ({review_rate:.1%}) is unusually high vs estimated sales — possible incentivized reviews",
+                "severity": "medium",
+                "weight": 20
+            })
+
+    # Signal 3: Very low review count but high BSR
+    # High sales rank but very few reviews = possibly review reset / new ASIN
+    if monthly_sales_estimate > 500 and review_count < 20:
+        suspicion_score += 15
+        signals.append({
+            "signal": "Sales/Review Mismatch",
+            "detail": f"High estimated sales ({monthly_sales_estimate:,}/mo) but only {review_count} reviews — possible review manipulation reset",
+            "severity": "medium",
+            "weight": 15
+        })
+
+    # Signal 4: Rating distribution analysis (if provided)
+    if rating_distribution:
+        five_star_pct = rating_distribution.get("5_star", 0)
+        one_star_pct  = rating_distribution.get("1_star", 0)
+        if five_star_pct > 85:
+            suspicion_score += 20
+            signals.append({
+                "signal": "Extreme 5-Star Concentration",
+                "detail": f"{five_star_pct}% five-star reviews — legitimate products rarely exceed 80%",
+                "severity": "high",
+                "weight": 20
+            })
+        if one_star_pct < 1 and review_count > 200:
+            suspicion_score += 10
+            signals.append({
+                "signal": "Missing Negative Reviews",
+                "detail": f"Only {one_star_pct}% 1-star reviews out of {review_count:,} — statistically unlikely for real products",
+                "severity": "medium",
+                "weight": 10
+            })
+
+    # Signal 5: Round number review counts often indicate manipulation
+    if review_count > 100:
+        str_count = str(review_count)
+        trailing_zeros = len(str_count) - len(str_count.rstrip("0"))
+        if trailing_zeros >= 2:
+            suspicion_score += 10
+            signals.append({
+                "signal": "Suspicious Review Count",
+                "detail": f"Round number ({review_count:,}) with trailing zeros — may indicate manipulated count",
+                "severity": "low",
+                "weight": 10
+            })
+
+    suspicion_score = min(suspicion_score, 100)
+
+    if suspicion_score >= 60:
+        verdict = "HIGH RISK — Likely Fake Reviews"
+        verdict_color = "#EF4444"
+        recommendation = "Avoid this product — high probability of review manipulation"
+    elif suspicion_score >= 35:
+        verdict = "MODERATE RISK — Suspicious Patterns"
+        verdict_color = "#F59E0B"
+        recommendation = "Investigate further before competing in this space"
+    elif suspicion_score >= 15:
+        verdict = "LOW RISK — Minor Concerns"
+        verdict_color = "#FB923C"
+        recommendation = "Reviews appear mostly genuine with minor anomalies"
+    else:
+        verdict = "AUTHENTIC — Reviews Appear Genuine"
+        verdict_color = "#10B981"
+        recommendation = "No significant red flags detected in review patterns"
+
+    return {
+        "suspicion_score": suspicion_score,
+        "verdict": verdict,
+        "verdict_color": verdict_color,
+        "recommendation": recommendation,
+        "signals": signals,
+        "signals_count": len(signals),
+        "is_suspicious": suspicion_score >= 35,
+        "analysis_basis": {
+            "rating": rating,
+            "review_count": review_count,
+            "monthly_sales_estimate": monthly_sales_estimate,
+        }
+    }
+
+
+# ═══════════════════════════════════════════════════════════════
+# 2. PRICE PREDICTION (Linear Regression)
+# ═══════════════════════════════════════════════════════════════
+
+def predict_price(
+    price_history: list,
+    days_ahead: int = 7
+) -> dict:
+    """
+    Predict future price using linear regression on price history.
+    price_history: list of {"price": float, "recorded_at": str}
+    """
+    if not price_history or len(price_history) < 3:
+        return {
+            "predicted_price": None,
+            "confidence": "low",
+            "trend": "insufficient_data",
+            "message": "Need at least 3 data points for prediction"
+        }
+
+    # Extract prices
+    prices = [float(p["price"]) for p in price_history if p.get("price")]
+    if len(prices) < 3:
+        return {"predicted_price": None, "confidence": "low", "trend": "insufficient_data"}
+
+    n = len(prices)
+    x = list(range(n))
+
+    # Linear regression: y = mx + b
+    sum_x  = sum(x)
+    sum_y  = sum(prices)
+    sum_xy = sum(x[i] * prices[i] for i in range(n))
+    sum_x2 = sum(xi ** 2 for xi in x)
+
+    denom = n * sum_x2 - sum_x ** 2
+    if denom == 0:
+        slope = 0
+    else:
+        slope = (n * sum_xy - sum_x * sum_y) / denom
+    intercept = (sum_y - slope * sum_x) / n
+
+    # Predict future price
+    future_x = n - 1 + days_ahead
+    predicted = round(intercept + slope * future_x, 2)
+    predicted = max(0.01, predicted)  # price can't be negative
+
+    # Calculate R² for confidence
+    y_mean = sum_y / n
+    ss_tot = sum((p - y_mean) ** 2 for p in prices)
+    ss_res = sum((prices[i] - (intercept + slope * x[i])) ** 2 for i in range(n))
+    r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0
+
+    # Determine trend
+    current_price = prices[-1]
+    price_change_pct = ((predicted - current_price) / current_price) * 100
+
+    if slope > 0.01:
+        trend = "rising"
+        trend_emoji = "📈"
+        trend_color = "#EF4444"
+    elif slope < -0.01:
+        trend = "falling"
+        trend_emoji = "📉"
+        trend_color = "#10B981"
+    else:
+        trend = "stable"
+        trend_emoji = "➡️"
+        trend_color = "#6B7280"
+
+    confidence = "high" if r2 > 0.7 else "medium" if r2 > 0.4 else "low"
+
+    # Price stats
+    min_price = min(prices)
+    max_price = max(prices)
+    avg_price = sum(prices) / len(prices)
+
+    return {
+        "predicted_price": predicted,
+        "current_price": current_price,
+        "price_change": round(predicted - current_price, 2),
+        "price_change_pct": round(price_change_pct, 1),
+        "trend": trend,
+        "trend_emoji": trend_emoji,
+        "trend_color": trend_color,
+        "confidence": confidence,
+        "r_squared": round(r2, 3),
+        "days_ahead": days_ahead,
+        "slope_per_day": round(slope, 4),
+        "price_stats": {
+            "min": round(min_price, 2),
+            "max": round(max_price, 2),
+            "avg": round(avg_price, 2),
+            "volatility": round((max_price - min_price) / avg_price * 100, 1)
+        },
+        "recommendation": (
+            f"Price expected to {'rise' if trend == 'rising' else 'fall' if trend == 'falling' else 'stay stable'} "
+            f"by {abs(price_change_pct):.1f}% over next {days_ahead} days"
+        )
+    }
+
+
+# ═══════════════════════════════════════════════════════════════
+# 3. DEMAND FORECASTING (Seasonality Detection)
+# ═══════════════════════════════════════════════════════════════
+
+def forecast_demand(
+    bsr_history: list,
+    category: str = "general",
+    current_month: Optional[int] = None
+) -> dict:
+    """
+    Forecast demand using BSR trends and seasonal patterns.
+    Lower BSR = higher demand.
+    """
+    if current_month is None:
+        current_month = datetime.now(timezone.utc).month
+
+    # Category seasonal multipliers (month 1-12)
+    seasonal_patterns = {
+        "electronics": [0.8, 0.7, 0.8, 0.9, 0.9, 0.8, 0.9, 0.9, 1.0, 1.0, 1.3, 1.4],
+        "home": [0.9, 0.8, 1.0, 1.1, 1.2, 1.1, 1.0, 0.9, 0.9, 1.0, 1.1, 1.0],
+        "toys": [0.7, 0.6, 0.7, 0.7, 0.8, 0.8, 0.9, 0.9, 1.0, 1.1, 1.3, 1.8],
+        "sports": [0.9, 0.9, 1.1, 1.2, 1.3, 1.3, 1.2, 1.1, 1.0, 0.9, 0.8, 0.8],
+        "kitchen": [0.9, 0.9, 1.0, 1.0, 1.0, 0.9, 0.9, 0.9, 0.9, 1.0, 1.1, 1.2],
+        "general":  [1.0, 0.9, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.1, 1.2],
+    }
+
+    # Match category
+    cat_key = "general"
+    category_lower = category.lower()
+    for key in seasonal_patterns:
+        if key in category_lower:
+            cat_key = key
+            break
+
+    pattern = seasonal_patterns[cat_key]
+    current_multiplier = pattern[current_month - 1]
+    next_month = (current_month % 12)
+    next_multiplier = pattern[next_month]
+
+    # BSR trend analysis
+    bsr_trend = "stable"
+    bsr_change_pct = 0
+    demand_trend = "stable"
+
+    if bsr_history and len(bsr_history) >= 3:
+        bsr_values = [h.get("bsr") for h in bsr_history if h.get("bsr")]
+        if len(bsr_values) >= 3:
+            old_bsr = sum(bsr_values[:3]) / 3
+            new_bsr = sum(bsr_values[-3:]) / 3
+            bsr_change_pct = ((new_bsr - old_bsr) / old_bsr) * 100
+
+            if bsr_change_pct < -10:
+                bsr_trend = "improving"  # BSR going down = demand going up
+                demand_trend = "increasing"
+            elif bsr_change_pct > 10:
+                bsr_trend = "declining"
+                demand_trend = "decreasing"
+            else:
+                bsr_trend = "stable"
+                demand_trend = "stable"
+
+    # Seasonal score for each month
+    months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]
+    monthly_forecast = []
+    for i, mult in enumerate(pattern):
+        monthly_forecast.append({
+            "month": months[i],
+            "demand_index": round(mult * 100),
+            "is_peak": mult >= 1.2,
+            "is_low": mult <= 0.8,
+        })
+
+    peak_months = [months[i] for i, m in enumerate(pattern) if m >= 1.2]
+    low_months  = [months[i] for i, m in enumerate(pattern) if m <= 0.8]
+
+    if current_multiplier >= 1.2:
+        season_status = "PEAK SEASON"
+        season_color = "#10B981"
+        season_advice = "Great time to sell — high demand period"
+    elif current_multiplier >= 1.0:
+        season_status = "NORMAL SEASON"
+        season_color = "#3B82F6"
+        season_advice = "Average demand — maintain stock levels"
+    elif current_multiplier >= 0.85:
+        season_status = "SLOW SEASON"
+        season_color = "#F59E0B"
+        season_advice = "Reduce inventory — lower demand period"
+    else:
+        season_status = "OFF SEASON"
+        season_color = "#EF4444"
+        season_advice = "Avoid heavy stock — very low demand"
+
+    demand_change_next = round((next_multiplier - current_multiplier) / current_multiplier * 100, 1)
+
+    return {
+        "current_season": season_status,
+        "season_color": season_color,
+        "season_advice": season_advice,
+        "current_demand_index": round(current_multiplier * 100),
+        "next_month_demand_index": round(next_multiplier * 100),
+        "demand_change_next_month": demand_change_next,
+        "demand_trend": demand_trend,
+        "bsr_trend": bsr_trend,
+        "bsr_change_pct": round(bsr_change_pct, 1),
+        "category": cat_key,
+        "peak_months": peak_months,
+        "low_months": low_months,
+        "monthly_forecast": monthly_forecast,
+        "recommendation": (
+            f"{season_status}: {season_advice}. "
+            f"Next month demand expected to {'increase' if demand_change_next > 5 else 'decrease' if demand_change_next < -5 else 'stay similar'} "
+            f"by {abs(demand_change_next):.0f}%."
+        )
+    }
+
+
+# ═══════════════════════════════════════════════════════════════
+# 4. NICHE SCORER
+# ═══════════════════════════════════════════════════════════════
+
+def score_niche(
+    keyword: str,
+    products: list,  # list of {bsr, price, reviews, rating}
+    category: str = "general"
+) -> dict:
+    """
+    Score an entire niche/keyword based on multiple product data points.
+    Returns opportunity score 0-100 and detailed breakdown.
+    """
+    if not products:
+        return {"error": "No products provided for niche analysis"}
+
+    prices   = [p.get("price", 0)   for p in products if p.get("price")]
+    bsrs     = [p.get("bsr", 0)     for p in products if p.get("bsr")]
+    reviews  = [p.get("reviews", 0) for p in products if p.get("reviews") is not None]
+    ratings  = [p.get("rating", 0)  for p in products if p.get("rating")]
+
+    def avg(lst): return sum(lst) / len(lst) if lst else 0
+    def median(lst):
+        s = sorted(lst)
+        n = len(s)
+        return (s[n//2] + s[n//2-1]) / 2 if n % 2 == 0 else s[n//2]
+
+    avg_price   = avg(prices)
+    avg_bsr     = avg(bsrs)
+    avg_reviews = avg(reviews)
+    avg_rating  = avg(ratings)
+    med_reviews = median(reviews) if reviews else 0
+
+    scores = {}
+
+    # 1. Demand Score (based on BSR)
+    if avg_bsr < 1000:
+        scores["demand"] = 95
+    elif avg_bsr < 5000:
+        scores["demand"] = 80
+    elif avg_bsr < 20000:
+        scores["demand"] = 65
+    elif avg_bsr < 100000:
+        scores["demand"] = 45
+    else:
+        scores["demand"] = 20
+
+    # 2. Competition Score (lower reviews = easier to compete)
+    if avg_reviews < 50:
+        scores["competition"] = 90
+    elif avg_reviews < 200:
+        scores["competition"] = 75
+    elif avg_reviews < 500:
+        scores["competition"] = 55
+    elif avg_reviews < 2000:
+        scores["competition"] = 35
+    else:
+        scores["competition"] = 15
+
+    # 3. Profitability Score (based on price)
+    if avg_price >= 25 and avg_price <= 70:
+        scores["profitability"] = 85
+    elif avg_price >= 15 and avg_price < 25:
+        scores["profitability"] = 65
+    elif avg_price >= 70 and avg_price <= 150:
+        scores["profitability"] = 70
+    elif avg_price > 150:
+        scores["profitability"] = 50
+    else:
+        scores["profitability"] = 35
+
+    # 4. Quality Gap Score (lower ratings = easier to beat with better product)
+    if avg_rating < 3.8:
+        scores["quality_gap"] = 90
+    elif avg_rating < 4.2:
+        scores["quality_gap"] = 70
+    elif avg_rating < 4.5:
+        scores["quality_gap"] = 50
+    else:
+        scores["quality_gap"] = 25
+
+    # 5. Market Size Score
+    n = len(products)
+    if n >= 10:
+        scores["market_size"] = 80
+    elif n >= 5:
+        scores["market_size"] = 60
+    else:
+        scores["market_size"] = 40
+
+    # Weighted total
+    total = (
+        scores["demand"]       * 0.30 +
+        scores["competition"]  * 0.30 +
+        scores["profitability"]* 0.20 +
+        scores["quality_gap"]  * 0.15 +
+        scores["market_size"]  * 0.05
+    )
+    total = round(total)
+
+    if total >= 70:
+        verdict = "Excellent Niche"
+        verdict_color = "#10B981"
+        recommendation = "Strong opportunity — low competition, good demand, profitable price range"
+    elif total >= 55:
+        verdict = "Good Niche"
+        verdict_color = "#3B82F6"
+        recommendation = "Decent opportunity — worth pursuing with right differentiation"
+    elif total >= 40:
+        verdict = "Moderate Niche"
+        verdict_color = "#F59E0B"
+        recommendation = "Average opportunity — possible but competitive, needs strong USP"
+    else:
+        verdict = "Tough Niche"
+        verdict_color = "#EF4444"
+        recommendation = "Difficult market — high competition or low margins"
+
+    # Review gaps — products with < 100 reviews in a market with demand
+    low_review_products = [p for p in products if (p.get("reviews") or 0) < 100 and (p.get("bsr") or 999999) < 50000]
+
+    return {
+        "keyword": keyword,
+        "niche_score": total,
+        "verdict": verdict,
+        "verdict_color": verdict_color,
+        "recommendation": recommendation,
+        "scores": {
+            "demand":        {"score": scores["demand"],        "label": "Market Demand",     "weight": "30%"},
+            "competition":   {"score": scores["competition"],   "label": "Competition Level", "weight": "30%"},
+            "profitability": {"score": scores["profitability"], "label": "Profitability",     "weight": "20%"},
+            "quality_gap":   {"score": scores["quality_gap"],  "label": "Quality Gap",       "weight": "15%"},
+            "market_size":   {"score": scores["market_size"],  "label": "Market Size",       "weight": "5%"},
+        },
+        "market_stats": {
+            "products_analyzed": len(products),
+            "avg_price": round(avg_price, 2),
+            "avg_bsr": round(avg_bsr),
+            "avg_reviews": round(avg_reviews),
+            "avg_rating": round(avg_rating, 1),
+            "median_reviews": round(med_reviews),
+        },
+        "opportunities": {
+            "low_review_opportunities": len(low_review_products),
+            "easy_entry_products": [p.get("asin", "") for p in low_review_products[:3]],
+            "price_gap": round(max(prices) - min(prices), 2) if prices else 0,
+        }
+    }

app/services/ml/niche_scorer.py

@@ -1,283 +1,283 @@
-# app/services/ml/niche_scorer.py
-# ─────────────────────────────────────────────────────────────────────────────
-# Niche Score — composite scoring of market opportunity.
-# Combines demand strength, competition difficulty, profitability potential,
-# entry barrier, and market trend into a single actionable score.
-#
-# Score: 0–100 where:
-#   80–100 = Excellent niche — enter now
-#   60–79  = Good opportunity — worth exploring
-#   40–59  = Average — proceed with differentiation
-#   20–39  = Difficult — needs strong USP
-#   0–19   = Saturated / not viable
-# ─────────────────────────────────────────────────────────────────────────────
-
-import math
-from typing import Optional
-
-
-def calculate_niche_score(
-    bsr: Optional[int],
-    review_count: int,
-    rating: float,
-    price: float,
-    monthly_sales: int,
-    seller_count: int,
-    is_fba: bool,
-    category: str = "",
-    price_history: Optional[list] = None,
-) -> dict:
-    """
-    Calculate comprehensive niche opportunity score.
-
-    Five dimensions (each 0–100, weighted):
-      1. Demand strength      (25%) — how much does the market want this?
-      2. Competition level    (25%) — how hard is it to break in?
-      3. Profitability        (20%) — how much money can be made?
-      4. Entry barrier        (15%) — how hard is it to enter?
-      5. Market stability     (15%) — is this a lasting opportunity?
-    """
-    dimensions = {}
-
-    # ── 1. Demand Strength (25%) ────────────────────────────────────────────
-    demand_score = 0
-    demand_notes = []
-
-    if bsr and bsr > 0:
-        if bsr < 1_000:      demand_score += 45; demand_notes.append("Elite BSR — massive demand")
-        elif bsr < 5_000:    demand_score += 40; demand_notes.append("Excellent BSR — strong demand")
-        elif bsr < 10_000:   demand_score += 35; demand_notes.append("Great BSR — good demand")
-        elif bsr < 25_000:   demand_score += 28; demand_notes.append("Solid BSR — moderate-high demand")
-        elif bsr < 50_000:   demand_score += 20; demand_notes.append("Decent BSR — moderate demand")
-        elif bsr < 100_000:  demand_score += 12; demand_notes.append("Fair BSR — low-moderate demand")
-        else:                demand_score += 4;  demand_notes.append("High BSR — low demand")
-
-    if monthly_sales >= 1000:    demand_score += 30; demand_notes.append("1,000+ units/month is excellent")
-    elif monthly_sales >= 500:   demand_score += 25; demand_notes.append("500+ units/month is strong")
-    elif monthly_sales >= 200:   demand_score += 18; demand_notes.append("200+ units/month is adequate")
-    elif monthly_sales >= 50:    demand_score += 10; demand_notes.append("50+ units/month — marginal")
-    else:                        demand_score += 2
-
-    if review_count > 500:       demand_score += 15; demand_notes.append("High review count confirms real demand")
-    elif review_count > 100:     demand_score += 10
-    elif review_count > 20:      demand_score += 5
-
-    demand_score = min(100, demand_score)
-    dimensions["demand"] = {
-        "score":  demand_score,
-        "weight": 0.25,
-        "label":  "Demand Strength",
-        "notes":  demand_notes[:2],
-    }
-
-    # ── 2. Competition Level (25%) — INVERTED (low comp = high score) ────────
-    comp_score = 100  # start at 100 and deduct for each barrier
-    comp_notes = []
-
-    # Review count as barrier (harder to beat many reviews)
-    if review_count > 5000:   comp_score -= 45; comp_notes.append(f"{review_count:,} reviews — very high barrier")
-    elif review_count > 2000: comp_score -= 35; comp_notes.append(f"{review_count:,} reviews — high barrier")
-    elif review_count > 500:  comp_score -= 20; comp_notes.append(f"{review_count:,} reviews — moderate barrier")
-    elif review_count > 100:  comp_score -= 10; comp_notes.append(f"{review_count:,} reviews — low barrier")
-    else:                     comp_notes.append(f"Only {review_count} reviews — easy to compete")
-
-    # Seller count
-    if seller_count > 20:     comp_score -= 25; comp_notes.append("Heavily contested market")
-    elif seller_count > 10:   comp_score -= 15; comp_notes.append("Competitive market")
-    elif seller_count > 5:    comp_score -= 8;  comp_notes.append("Moderate competition")
-    else:                     comp_notes.append(f"Only {seller_count} sellers — low competition")
-
-    # Rating raises bar
-    if rating >= 4.7:         comp_score -= 10; comp_notes.append("Existing sellers have excellent ratings")
-    elif rating < 4.0 and rating > 0:
-                              comp_score += 10; comp_notes.append("Poor existing ratings — easy to differentiate")
-
-    comp_score = max(0, min(100, comp_score))
-    dimensions["competition"] = {
-        "score":  comp_score,
-        "weight": 0.25,
-        "label":  "Competition Level",
-        "notes":  comp_notes[:2],
-    }
-
-    # ── 3. Profitability (20%) ───────────────────────────────────────────────
-    profit_score = 0
-    profit_notes = []
-
-    # FBA fee structure: approx 15% referral + $3-5 FBA fee
-    if price > 0:
-        fba_fee        = 3.5 + (price * 0.02)  # simplified FBA estimate
-        referral_fee   = price * 0.15
-        estimated_cogs = price * 0.30           # typical 30% COGS for FBA
-        estimated_profit = price - fba_fee - referral_fee - estimated_cogs
-        margin_pct     = (estimated_profit / price * 100) if price > 0 else 0
-
-        if price >= 25:      profit_score += 35; profit_notes.append(f"${price:.2f} price supports healthy margins")
-        elif price >= 15:    profit_score += 25; profit_notes.append(f"${price:.2f} is workable for FBA")
-        elif price >= 10:    profit_score += 15; profit_notes.append(f"${price:.2f} is tight margin territory")
-        else:                profit_score += 5;  profit_notes.append(f"${price:.2f} is too low for FBA profitability")
-
-        if margin_pct >= 30: profit_score += 40; profit_notes.append(f"Est. {margin_pct:.0f}% margin — excellent")
-        elif margin_pct >= 20: profit_score += 30; profit_notes.append(f"Est. {margin_pct:.0f}% margin — good")
-        elif margin_pct >= 10: profit_score += 18; profit_notes.append(f"Est. {margin_pct:.0f}% margin — acceptable")
-        else:                  profit_score += 5;  profit_notes.append(f"Est. {margin_pct:.0f}% margin — poor")
-
-    # Revenue potential
-    monthly_revenue = monthly_sales * price if price > 0 and monthly_sales > 0 else 0
-    if monthly_revenue >= 10000:  profit_score += 20
-    elif monthly_revenue >= 5000: profit_score += 15
-    elif monthly_revenue >= 2000: profit_score += 10
-    elif monthly_revenue >= 500:  profit_score += 5
-
-    profit_score = min(100, profit_score)
-    dimensions["profitability"] = {
-        "score":  profit_score,
-        "weight": 0.20,
-        "label":  "Profitability",
-        "notes":  profit_notes[:2],
-    }
-
-    # ── 4. Entry Barrier (15%) — INVERTED (low barrier = high score) ─────────
-    entry_score = 80  # start generous
-    entry_notes = []
-
-    # FBA sellers are harder to beat on logistics
-    if is_fba: entry_score -= 10; entry_notes.append("FBA competitors have logistics advantage")
-
-    # Patent / brand risk (proxy: established seller + high rating)
-    if review_count > 1000 and rating >= 4.6:
-        entry_score -= 20; entry_notes.append("Strong incumbent brand — needs differentiation")
-    elif review_count > 200:
-        entry_score -= 8
-
-    # Price point — low prices mean less room for error
-    if price < 15: entry_score -= 15; entry_notes.append("Low price point — thin margin for mistakes")
-    elif price > 50: entry_score += 10; entry_notes.append("Premium price point — room for quality differentiation")
-
-    if not entry_notes:
-        entry_notes.append("Low entry barriers — good opportunity for new seller")
-
-    entry_score = max(0, min(100, entry_score))
-    dimensions["entry_barrier"] = {
-        "score":  entry_score,
-        "weight": 0.15,
-        "label":  "Entry Barrier",
-        "notes":  entry_notes[:2],
-    }
-
-    # ── 5. Market Stability (15%) ────────────────────────────────────────────
-    stability_score = 60  # default neutral
-    stability_notes = []
-
-    # Price stability (if history available)
-    if price_history and len(price_history) >= 3:
-        prices = [p["price"] for p in price_history if p.get("price") and p["price"] > 0]
-        if len(prices) >= 3:
-            avg_price = sum(prices) / len(prices)
-            variance  = sum((p - avg_price) ** 2 for p in prices) / len(prices)
-            std_dev   = math.sqrt(variance)
-            cv        = std_dev / avg_price if avg_price > 0 else 0  # coefficient of variation
-            if cv < 0.05:
-                stability_score += 20; stability_notes.append("Very stable pricing history")
-            elif cv < 0.10:
-                stability_score += 10; stability_notes.append("Reasonably stable pricing")
-            elif cv > 0.20:
-                stability_score -= 15; stability_notes.append("High price volatility — risky market")
-
-    # Category stability proxy
-    stable_categories = ["home", "kitchen", "tools", "office", "sports", "garden"]
-    volatile_categories = ["electronics", "tech", "gaming", "trending"]
-    cat_lower = category.lower()
-    if any(c in cat_lower for c in stable_categories):
-        stability_score += 10; stability_notes.append("Evergreen category — consistent year-round demand")
-    elif any(c in cat_lower for c in volatile_categories):
-        stability_score -= 10; stability_notes.append("Fast-moving category — trends change quickly")
-
-    if not stability_notes:
-        stability_notes.append("Market stability appears adequate for FBA business")
-
-    stability_score = max(0, min(100, stability_score))
-    dimensions["stability"] = {
-        "score":  stability_score,
-        "weight": 0.15,
-        "label":  "Market Stability",
-        "notes":  stability_notes[:2],
-    }
-
-    # ── Weighted composite score ─────────────────────────────────────────────
-    niche_score = int(sum(d["score"] * d["weight"] for d in dimensions.values()))
-
-    # ── Grade and verdict ────────────────────────────────────────────────────
-    if niche_score >= 80:
-        grade   = "A"
-        verdict = "Excellent niche opportunity"
-        action  = "Enter now — strong demand, manageable competition, good margins"
-        color   = "green"
-    elif niche_score >= 65:
-        grade   = "B"
-        verdict = "Good opportunity worth pursuing"
-        action  = "Proceed with a differentiated product — find a gap in existing listings"
-        color   = "teal"
-    elif niche_score >= 50:
-        grade   = "C"
-        verdict = "Average opportunity — needs careful execution"
-        action  = "Only enter with a clear USP (unique design, bundle, or brand story)"
-        color   = "amber"
-    elif niche_score >= 35:
-        grade   = "D"
-        verdict = "Difficult niche — high risk"
-        action  = "High competition and low margins make this risky. Look for adjacent niches."
-        color   = "orange"
-    else:
-        grade   = "F"
-        verdict = "Not recommended — saturated or unviable"
-        action  = "Avoid this product. Move on to a different niche."
-        color   = "red"
-
-    result = {
-        "niche_score":  niche_score,
-        "grade":        grade,
-        "verdict":      verdict,
-        "action":       action,
-        "color":        color,
-        "dimensions":   dimensions,
-        "engine":       "heuristic",
-        "model":        "weighted-composite",
-        "summary": {
-            "demand_score":       dimensions["demand"]["score"],
-            "competition_score":  dimensions["competition"]["score"],
-            "profit_score":       dimensions["profitability"]["score"],
-            "entry_score":        dimensions["entry_barrier"]["score"],
-            "stability_score":    dimensions["stability"]["score"],
-        },
-    }
-
-    try:
-        from app.services.ml.sklearn_engine import get_engine
-        engine = get_engine()
-        if engine:
-            ml = engine.predict_niche_score(
-                bsr, review_count, rating, price, monthly_sales, seller_count, is_fba
-            )
-            blended = int(min(100, max(0, ml["niche_score"] * 0.55 + niche_score * 0.45)))
-            result["niche_score"] = blended
-            result["grade"] = ml["grade"]
-            result["verdict"] = ml["verdict"]
-            result["action"] = ml["action"]
-            result["engine"] = "sklearn+heuristic"
-            result["model"] = ml.get("model", "GradientBoostingRegressor")
-            result["model_version"] = ml.get("model_version")
-            if blended >= 80:
-                result["color"] = "green"
-            elif blended >= 65:
-                result["color"] = "teal"
-            elif blended >= 50:
-                result["color"] = "amber"
-            elif blended >= 35:
-                result["color"] = "orange"
-            else:
-                result["color"] = "red"
-    except Exception as e:
-        print(f"[niche_scorer] sklearn blend failed: {e}")
-
+# app/services/ml/niche_scorer.py
+# ─────────────────────────────────────────────────────────────────────────────
+# Niche Score — composite scoring of market opportunity.
+# Combines demand strength, competition difficulty, profitability potential,
+# entry barrier, and market trend into a single actionable score.
+#
+# Score: 0–100 where:
+#   80–100 = Excellent niche — enter now
+#   60–79  = Good opportunity — worth exploring
+#   40–59  = Average — proceed with differentiation
+#   20–39  = Difficult — needs strong USP
+#   0–19   = Saturated / not viable
+# ─────────────────────────────────────────────────────────────────────────────
+
+import math
+from typing import Optional
+
+
+def calculate_niche_score(
+    bsr: Optional[int],
+    review_count: int,
+    rating: float,
+    price: float,
+    monthly_sales: int,
+    seller_count: int,
+    is_fba: bool,
+    category: str = "",
+    price_history: Optional[list] = None,
+) -> dict:
+    """
+    Calculate comprehensive niche opportunity score.
+
+    Five dimensions (each 0–100, weighted):
+      1. Demand strength      (25%) — how much does the market want this?
+      2. Competition level    (25%) — how hard is it to break in?
+      3. Profitability        (20%) — how much money can be made?
+      4. Entry barrier        (15%) — how hard is it to enter?
+      5. Market stability     (15%) — is this a lasting opportunity?
+    """
+    dimensions = {}
+
+    # ── 1. Demand Strength (25%) ────────────────────────────────────────────
+    demand_score = 0
+    demand_notes = []
+
+    if bsr and bsr > 0:
+        if bsr < 1_000:      demand_score += 45; demand_notes.append("Elite BSR — massive demand")
+        elif bsr < 5_000:    demand_score += 40; demand_notes.append("Excellent BSR — strong demand")
+        elif bsr < 10_000:   demand_score += 35; demand_notes.append("Great BSR — good demand")
+        elif bsr < 25_000:   demand_score += 28; demand_notes.append("Solid BSR — moderate-high demand")
+        elif bsr < 50_000:   demand_score += 20; demand_notes.append("Decent BSR — moderate demand")
+        elif bsr < 100_000:  demand_score += 12; demand_notes.append("Fair BSR — low-moderate demand")
+        else:                demand_score += 4;  demand_notes.append("High BSR — low demand")
+
+    if monthly_sales >= 1000:    demand_score += 30; demand_notes.append("1,000+ units/month is excellent")
+    elif monthly_sales >= 500:   demand_score += 25; demand_notes.append("500+ units/month is strong")
+    elif monthly_sales >= 200:   demand_score += 18; demand_notes.append("200+ units/month is adequate")
+    elif monthly_sales >= 50:    demand_score += 10; demand_notes.append("50+ units/month — marginal")
+    else:                        demand_score += 2
+
+    if review_count > 500:       demand_score += 15; demand_notes.append("High review count confirms real demand")
+    elif review_count > 100:     demand_score += 10
+    elif review_count > 20:      demand_score += 5
+
+    demand_score = min(100, demand_score)
+    dimensions["demand"] = {
+        "score":  demand_score,
+        "weight": 0.25,
+        "label":  "Demand Strength",
+        "notes":  demand_notes[:2],
+    }
+
+    # ── 2. Competition Level (25%) — INVERTED (low comp = high score) ────────
+    comp_score = 100  # start at 100 and deduct for each barrier
+    comp_notes = []
+
+    # Review count as barrier (harder to beat many reviews)
+    if review_count > 5000:   comp_score -= 45; comp_notes.append(f"{review_count:,} reviews — very high barrier")
+    elif review_count > 2000: comp_score -= 35; comp_notes.append(f"{review_count:,} reviews — high barrier")
+    elif review_count > 500:  comp_score -= 20; comp_notes.append(f"{review_count:,} reviews — moderate barrier")
+    elif review_count > 100:  comp_score -= 10; comp_notes.append(f"{review_count:,} reviews — low barrier")
+    else:                     comp_notes.append(f"Only {review_count} reviews — easy to compete")
+
+    # Seller count
+    if seller_count > 20:     comp_score -= 25; comp_notes.append("Heavily contested market")
+    elif seller_count > 10:   comp_score -= 15; comp_notes.append("Competitive market")
+    elif seller_count > 5:    comp_score -= 8;  comp_notes.append("Moderate competition")
+    else:                     comp_notes.append(f"Only {seller_count} sellers — low competition")
+
+    # Rating raises bar
+    if rating >= 4.7:         comp_score -= 10; comp_notes.append("Existing sellers have excellent ratings")
+    elif rating < 4.0 and rating > 0:
+                              comp_score += 10; comp_notes.append("Poor existing ratings — easy to differentiate")
+
+    comp_score = max(0, min(100, comp_score))
+    dimensions["competition"] = {
+        "score":  comp_score,
+        "weight": 0.25,
+        "label":  "Competition Level",
+        "notes":  comp_notes[:2],
+    }
+
+    # ── 3. Profitability (20%) ───────────────────────────────────────────────
+    profit_score = 0
+    profit_notes = []
+
+    # FBA fee structure: approx 15% referral + $3-5 FBA fee
+    if price > 0:
+        fba_fee        = 3.5 + (price * 0.02)  # simplified FBA estimate
+        referral_fee   = price * 0.15
+        estimated_cogs = price * 0.30           # typical 30% COGS for FBA
+        estimated_profit = price - fba_fee - referral_fee - estimated_cogs
+        margin_pct     = (estimated_profit / price * 100) if price > 0 else 0
+
+        if price >= 25:      profit_score += 35; profit_notes.append(f"${price:.2f} price supports healthy margins")
+        elif price >= 15:    profit_score += 25; profit_notes.append(f"${price:.2f} is workable for FBA")
+        elif price >= 10:    profit_score += 15; profit_notes.append(f"${price:.2f} is tight margin territory")
+        else:                profit_score += 5;  profit_notes.append(f"${price:.2f} is too low for FBA profitability")
+
+        if margin_pct >= 30: profit_score += 40; profit_notes.append(f"Est. {margin_pct:.0f}% margin — excellent")
+        elif margin_pct >= 20: profit_score += 30; profit_notes.append(f"Est. {margin_pct:.0f}% margin — good")
+        elif margin_pct >= 10: profit_score += 18; profit_notes.append(f"Est. {margin_pct:.0f}% margin — acceptable")
+        else:                  profit_score += 5;  profit_notes.append(f"Est. {margin_pct:.0f}% margin — poor")
+
+    # Revenue potential
+    monthly_revenue = monthly_sales * price if price > 0 and monthly_sales > 0 else 0
+    if monthly_revenue >= 10000:  profit_score += 20
+    elif monthly_revenue >= 5000: profit_score += 15
+    elif monthly_revenue >= 2000: profit_score += 10
+    elif monthly_revenue >= 500:  profit_score += 5
+
+    profit_score = min(100, profit_score)
+    dimensions["profitability"] = {
+        "score":  profit_score,
+        "weight": 0.20,
+        "label":  "Profitability",
+        "notes":  profit_notes[:2],
+    }
+
+    # ── 4. Entry Barrier (15%) — INVERTED (low barrier = high score) ─────────
+    entry_score = 80  # start generous
+    entry_notes = []
+
+    # FBA sellers are harder to beat on logistics
+    if is_fba: entry_score -= 10; entry_notes.append("FBA competitors have logistics advantage")
+
+    # Patent / brand risk (proxy: established seller + high rating)
+    if review_count > 1000 and rating >= 4.6:
+        entry_score -= 20; entry_notes.append("Strong incumbent brand — needs differentiation")
+    elif review_count > 200:
+        entry_score -= 8
+
+    # Price point — low prices mean less room for error
+    if price < 15: entry_score -= 15; entry_notes.append("Low price point — thin margin for mistakes")
+    elif price > 50: entry_score += 10; entry_notes.append("Premium price point — room for quality differentiation")
+
+    if not entry_notes:
+        entry_notes.append("Low entry barriers — good opportunity for new seller")
+
+    entry_score = max(0, min(100, entry_score))
+    dimensions["entry_barrier"] = {
+        "score":  entry_score,
+        "weight": 0.15,
+        "label":  "Entry Barrier",
+        "notes":  entry_notes[:2],
+    }
+
+    # ── 5. Market Stability (15%) ────────────────────────────────────────────
+    stability_score = 60  # default neutral
+    stability_notes = []
+
+    # Price stability (if history available)
+    if price_history and len(price_history) >= 3:
+        prices = [p["price"] for p in price_history if p.get("price") and p["price"] > 0]
+        if len(prices) >= 3:
+            avg_price = sum(prices) / len(prices)
+            variance  = sum((p - avg_price) ** 2 for p in prices) / len(prices)
+            std_dev   = math.sqrt(variance)
+            cv        = std_dev / avg_price if avg_price > 0 else 0  # coefficient of variation
+            if cv < 0.05:
+                stability_score += 20; stability_notes.append("Very stable pricing history")
+            elif cv < 0.10:
+                stability_score += 10; stability_notes.append("Reasonably stable pricing")
+            elif cv > 0.20:
+                stability_score -= 15; stability_notes.append("High price volatility — risky market")
+
+    # Category stability proxy
+    stable_categories = ["home", "kitchen", "tools", "office", "sports", "garden"]
+    volatile_categories = ["electronics", "tech", "gaming", "trending"]
+    cat_lower = category.lower()
+    if any(c in cat_lower for c in stable_categories):
+        stability_score += 10; stability_notes.append("Evergreen category — consistent year-round demand")
+    elif any(c in cat_lower for c in volatile_categories):
+        stability_score -= 10; stability_notes.append("Fast-moving category — trends change quickly")
+
+    if not stability_notes:
+        stability_notes.append("Market stability appears adequate for FBA business")
+
+    stability_score = max(0, min(100, stability_score))
+    dimensions["stability"] = {
+        "score":  stability_score,
+        "weight": 0.15,
+        "label":  "Market Stability",
+        "notes":  stability_notes[:2],
+    }
+
+    # ── Weighted composite score ─────────────────────────────────────────────
+    niche_score = int(sum(d["score"] * d["weight"] for d in dimensions.values()))
+
+    # ── Grade and verdict ───────────────────────────���────────────────────────
+    if niche_score >= 80:
+        grade   = "A"
+        verdict = "Excellent niche opportunity"
+        action  = "Enter now — strong demand, manageable competition, good margins"
+        color   = "green"
+    elif niche_score >= 65:
+        grade   = "B"
+        verdict = "Good opportunity worth pursuing"
+        action  = "Proceed with a differentiated product — find a gap in existing listings"
+        color   = "teal"
+    elif niche_score >= 50:
+        grade   = "C"
+        verdict = "Average opportunity — needs careful execution"
+        action  = "Only enter with a clear USP (unique design, bundle, or brand story)"
+        color   = "amber"
+    elif niche_score >= 35:
+        grade   = "D"
+        verdict = "Difficult niche — high risk"
+        action  = "High competition and low margins make this risky. Look for adjacent niches."
+        color   = "orange"
+    else:
+        grade   = "F"
+        verdict = "Not recommended — saturated or unviable"
+        action  = "Avoid this product. Move on to a different niche."
+        color   = "red"
+
+    result = {
+        "niche_score":  niche_score,
+        "grade":        grade,
+        "verdict":      verdict,
+        "action":       action,
+        "color":        color,
+        "dimensions":   dimensions,
+        "engine":       "heuristic",
+        "model":        "weighted-composite",
+        "summary": {
+            "demand_score":       dimensions["demand"]["score"],
+            "competition_score":  dimensions["competition"]["score"],
+            "profit_score":       dimensions["profitability"]["score"],
+            "entry_score":        dimensions["entry_barrier"]["score"],
+            "stability_score":    dimensions["stability"]["score"],
+        },
+    }
+
+    try:
+        from app.services.ml.sklearn_engine import get_engine
+        engine = get_engine()
+        if engine:
+            ml = engine.predict_niche_score(
+                bsr, review_count, rating, price, monthly_sales, seller_count, is_fba
+            )
+            blended = int(min(100, max(0, ml["niche_score"] * 0.55 + niche_score * 0.45)))
+            result["niche_score"] = blended
+            result["grade"] = ml["grade"]
+            result["verdict"] = ml["verdict"]
+            result["action"] = ml["action"]
+            result["engine"] = "sklearn+heuristic"
+            result["model"] = ml.get("model", "GradientBoostingRegressor")
+            result["model_version"] = ml.get("model_version")
+            if blended >= 80:
+                result["color"] = "green"
+            elif blended >= 65:
+                result["color"] = "teal"
+            elif blended >= 50:
+                result["color"] = "amber"
+            elif blended >= 35:
+                result["color"] = "orange"
+            else:
+                result["color"] = "red"
+    except Exception as e:
+        print(f"[niche_scorer] sklearn blend failed: {e}")
+
     return result

app/services/ml/price_predictor.py

@@ -1,240 +1,240 @@
-# app/services/ml/price_predictor.py
-# ─────────────────────────────────────────────────────────────────────────────
-# Price Prediction using linear regression on BSR-to-price relationship.
-#
-# Academic basis: Simple linear regression (ordinary least squares).
-# We use the well-documented inverse relationship between Amazon BSR and
-# optimal pricing to predict where prices are likely to move.
-#
-# Model inputs:  current_price, bsr, rating, review_count, seller_count
-# Outputs:       predicted price in 30/60/90 days + confidence interval
-# ─────────────────────────────────────────────────────────────────────────────
-
-import math
-from typing import Optional
-
-
-# Amazon category average prices (empirical from seller data)
-_CATEGORY_BASELINES = {
-    "electronics":        45.0,
-    "home & kitchen":     25.0,
-    "clothing":           22.0,
-    "books":              14.0,
-    "toys & games":       20.0,
-    "sports":             28.0,
-    "health":             18.0,
-    "beauty":             16.0,
-    "tools":              32.0,
-    "grocery":            12.0,
-    "default":            24.0,
-}
-
-
-def predict_price(
-    current_price: float,
-    bsr: Optional[int],
-    rating: float,
-    review_count: int,
-    seller_count: int = 1,
-    category: str = "",
-    price_history: Optional[list] = None,
-) -> dict:
-    """
-    Predict future price movements for an Amazon product.
-
-    Uses a regression model combining:
-    - BSR pressure coefficient (high BSR → price pressure downward)
-    - Competition coefficient (more sellers → price drops)
-    - Review momentum (growing reviews → can sustain higher price)
-    - Historical trend (if price_history available)
-
-    Returns predictions for 30, 60, 90 days with confidence intervals.
-    """
-    if current_price <= 0:
-        return _empty_prediction(current_price)
-
-    # ── Category baseline ────────────────────────────────────────────────────
-    cat_key = category.lower() if category else "default"
-    baseline = next(
-        (v for k, v in _CATEGORY_BASELINES.items() if k in cat_key),
-        _CATEGORY_BASELINES["default"]
-    )
-
-    # ── BSR pressure coefficient ─────────────────────────────────────────────
-    # High BSR (poor rank) = product is losing — price pressure downward
-    # Low BSR (good rank) = product is winning — can sustain or raise price
-    if bsr and bsr > 0:
-        # Normalise BSR: rank 1 = 1.0, rank 1,000,000 = 0.0
-        bsr_norm = max(0.0, 1.0 - math.log10(bsr) / 6.0)  # log10(1M) = 6
-        bsr_coeff = (bsr_norm - 0.5) * 0.08   # -4% to +4% per month pressure
-    else:
-        bsr_norm  = 0.5
-        bsr_coeff = 0.0
-
-    # ── Competition coefficient ──────────────────────────────────────────────
-    # More sellers = race to bottom = price drops ~1-2% per extra seller
-    competition_coeff = -0.012 * max(0, seller_count - 1)  # -1.2% per extra seller
-
-    # ── Review momentum ──────────────────────────────────────────────────────
-    # Products gaining reviews can hold or slightly raise prices
-    # High rating + many reviews = pricing power
-    review_norm  = min(1.0, math.log10(max(1, review_count)) / 4.0)  # 0–1
-    rating_power = (rating - 3.0) / 2.0 if rating > 0 else 0          # -1.5 to +1
-    review_coeff = review_norm * rating_power * 0.015  # up to +1.5% / month
-
-    # ── Historical trend (if available) ──────────────────────────────────────
-    historical_monthly_change = 0.0
-    trend_confidence_bonus = 0
-    if price_history and len(price_history) >= 3:
-        prices = [p["price"] for p in price_history if p.get("price")]
-        if len(prices) >= 3:
-            # Simple linear regression slope
-            n = len(prices)
-            x_mean = (n - 1) / 2
-            y_mean = sum(prices) / n
-            numerator   = sum((i - x_mean) * (prices[i] - y_mean) for i in range(n))
-            denominator = sum((i - x_mean) ** 2 for i in range(n))
-            if denominator > 0:
-                slope = numerator / denominator  # price change per period
-                # Convert to monthly % change
-                historical_monthly_change = slope / prices[0] if prices[0] > 0 else 0
-            trend_confidence_bonus = 15  # more confident with real data
-
-    # ── Combine coefficients ─────────────────────────────────────────────────
-    if historical_monthly_change != 0:
-        # Weight historical trend 60%, model 40%
-        model_monthly = bsr_coeff + competition_coeff + review_coeff
-        monthly_change_rate = 0.6 * historical_monthly_change + 0.4 * model_monthly
-    else:
-        monthly_change_rate = bsr_coeff + competition_coeff + review_coeff
-
-    # Cap monthly change: Amazon prices rarely move more than ±8% per month
-    monthly_change_rate = max(-0.08, min(0.08, monthly_change_rate))
-
-    # ── Predictions ──────────────────────────────────────────────────────────
-    p30  = round(current_price * (1 + monthly_change_rate),      2)
-    p60  = round(current_price * (1 + monthly_change_rate * 2),  2)
-    p90  = round(current_price * (1 + monthly_change_rate * 3),  2)
-
-    # Ensure prices stay positive
-    p30  = max(0.99, p30)
-    p60  = max(0.99, p60)
-    p90  = max(0.99, p90)
-
-    # ── Confidence interval (±%) ──────────────────────────────────────────────
-    # Less data → wider interval
-    base_uncertainty = 0.08  # ±8% base
-    if bsr: base_uncertainty -= 0.02
-    if review_count > 100: base_uncertainty -= 0.01
-    if price_history and len(price_history) >= 5: base_uncertainty -= 0.02
-    uncertainty = max(0.03, base_uncertainty)
-
-    # ── Confidence score ──────────────────────────────────────────────────────
-    confidence = 55 + trend_confidence_bonus
-    if bsr and bsr > 0: confidence += 10
-    if review_count > 50: confidence += 8
-    if price_history and len(price_history) >= 3: confidence += 12
-    confidence = min(92, confidence)
-
-    # ── Direction label ───────────────────────────────────────────────────────
-    if monthly_change_rate > 0.02:
-        direction = "upward"
-        direction_label = "Price likely to rise"
-        direction_reason = _build_reason(bsr_coeff, competition_coeff, review_coeff, "up")
-    elif monthly_change_rate < -0.02:
-        direction = "downward"
-        direction_label = "Price likely to decrease"
-        direction_reason = _build_reason(bsr_coeff, competition_coeff, review_coeff, "down")
-    else:
-        direction = "stable"
-        direction_label = "Price likely to remain stable"
-        direction_reason = "Competing forces are balanced — no strong movement expected"
-
-    # ── Pricing recommendation ────────────────────────────────────────────────
-    if direction == "downward" and abs(monthly_change_rate) > 0.04:
-        recommendation = f"Consider sourcing now before price drops further. Target entry price: ${p90:.2f}"
-    elif direction == "upward":
-        recommendation = f"Price trending up — list sooner. Predicted ceiling: ${p90:.2f}"
-    else:
-        recommendation = f"Stable pricing environment. Current price ${current_price:.2f} is representative of near-term market."
-
-    result = {
-        "current_price":  current_price,
-        "predictions": {
-            "days_30": {"price": p30, "change_pct": round((p30 - current_price) / current_price * 100, 1),
-                        "low": round(p30 * (1 - uncertainty), 2), "high": round(p30 * (1 + uncertainty), 2)},
-            "days_60": {"price": p60, "change_pct": round((p60 - current_price) / current_price * 100, 1),
-                        "low": round(p60 * (1 - uncertainty), 2), "high": round(p60 * (1 + uncertainty), 2)},
-            "days_90": {"price": p90, "change_pct": round((p90 - current_price) / current_price * 100, 1),
-                        "low": round(p90 * (1 - uncertainty), 2), "high": round(p90 * (1 + uncertainty), 2)},
-        },
-        "direction":         direction,
-        "direction_label":   direction_label,
-        "direction_reason":  direction_reason,
-        "monthly_change_pct": round(monthly_change_rate * 100, 2),
-        "confidence":        confidence,
-        "recommendation":    recommendation,
-        "engine":            "heuristic",
-        "model":             "linear-regression",
-        "model_factors": {
-            "bsr_pressure":      round(bsr_coeff * 100, 2),
-            "competition_pressure": round(competition_coeff * 100, 2),
-            "review_momentum":   round(review_coeff * 100, 2),
-            "historical_trend":  round(historical_monthly_change * 100, 2) if historical_monthly_change else None,
-        },
-    }
-
-    try:
-        from app.services.ml.sklearn_engine import get_engine
-        engine = get_engine()
-        if engine:
-            ml = engine.predict_price_delta(current_price, bsr, rating, review_count, seller_count)
-            result["predictions"] = ml["predictions"]
-            result["monthly_change_pct"] = ml["monthly_change_pct"]
-            result["model_factors"] = {**result["model_factors"], **ml["model_factors"]}
-            result["confidence"] = max(confidence, ml.get("confidence", 70))
-            result["engine"] = "sklearn+heuristic"
-            result["model"] = ml.get("model", "GradientBoostingRegressor")
-            result["model_version"] = ml.get("model_version")
-            d = ml["direction"]
-            result["direction"] = "upward" if d == "up" else "downward" if d == "down" else "stable"
-            result["direction_label"] = ml["direction_label"]
-            result["direction_reason"] = (
-                f"Scikit-learn price model predicts {ml['monthly_change_pct']:+.1f}% over 30 days "
-                f"(blended with BSR/competition signals)."
-            )
-    except Exception as e:
-        print(f"[price_predictor] sklearn blend failed: {e}")
-
-    return result
-
-
-def _build_reason(bsr_c, comp_c, rev_c, direction):
-    factors = []
-    if abs(bsr_c) > 0.01:
-        factors.append("BSR rank pressure" if bsr_c > 0 else "weak sales rank pushing price down")
-    if abs(comp_c) > 0.01:
-        factors.append(f"competition ({abs(comp_c)*100:.1f}% downward pressure)")
-    if abs(rev_c) > 0.005:
-        factors.append("strong review momentum supporting price" if rev_c > 0 else "declining review sentiment")
-    if not factors:
-        return "Marginal pressure from market dynamics"
-    return "Driven by: " + ", ".join(factors)
-
-
-def _empty_prediction(price):
-    return {
-        "current_price": price,
-        "predictions": {
-            "days_30": {"price": price, "change_pct": 0.0, "low": price, "high": price},
-            "days_60": {"price": price, "change_pct": 0.0, "low": price, "high": price},
-            "days_90": {"price": price, "change_pct": 0.0, "low": price, "high": price},
-        },
-        "direction": "stable",
-        "direction_label": "Insufficient data",
-        "direction_reason": "Not enough data to make a prediction",
-        "monthly_change_pct": 0.0,
-        "confidence": 20,
-        "recommendation": "Gather more data by tracking this product over time.",
-        "model_factors": {"bsr_pressure": 0, "competition_pressure": 0, "review_momentum": 0, "historical_trend": None},
+# app/services/ml/price_predictor.py
+# ─────────────────────────────────────────────────────────────────────────────
+# Price Prediction using linear regression on BSR-to-price relationship.
+#
+# Academic basis: Simple linear regression (ordinary least squares).
+# We use the well-documented inverse relationship between Amazon BSR and
+# optimal pricing to predict where prices are likely to move.
+#
+# Model inputs:  current_price, bsr, rating, review_count, seller_count
+# Outputs:       predicted price in 30/60/90 days + confidence interval
+# ─────────────────────────────────────────────────────────────────────────────
+
+import math
+from typing import Optional
+
+
+# Amazon category average prices (empirical from seller data)
+_CATEGORY_BASELINES = {
+    "electronics":        45.0,
+    "home & kitchen":     25.0,
+    "clothing":           22.0,
+    "books":              14.0,
+    "toys & games":       20.0,
+    "sports":             28.0,
+    "health":             18.0,
+    "beauty":             16.0,
+    "tools":              32.0,
+    "grocery":            12.0,
+    "default":            24.0,
+}
+
+
+def predict_price(
+    current_price: float,
+    bsr: Optional[int],
+    rating: float,
+    review_count: int,
+    seller_count: int = 1,
+    category: str = "",
+    price_history: Optional[list] = None,
+) -> dict:
+    """
+    Predict future price movements for an Amazon product.
+
+    Uses a regression model combining:
+    - BSR pressure coefficient (high BSR → price pressure downward)
+    - Competition coefficient (more sellers → price drops)
+    - Review momentum (growing reviews → can sustain higher price)
+    - Historical trend (if price_history available)
+
+    Returns predictions for 30, 60, 90 days with confidence intervals.
+    """
+    if current_price <= 0:
+        return _empty_prediction(current_price)
+
+    # ── Category baseline ────────────────────────────────────────────────────
+    cat_key = category.lower() if category else "default"
+    baseline = next(
+        (v for k, v in _CATEGORY_BASELINES.items() if k in cat_key),
+        _CATEGORY_BASELINES["default"]
+    )
+
+    # ── BSR pressure coefficient ─────────────────────────────────────────────
+    # High BSR (poor rank) = product is losing — price pressure downward
+    # Low BSR (good rank) = product is winning — can sustain or raise price
+    if bsr and bsr > 0:
+        # Normalise BSR: rank 1 = 1.0, rank 1,000,000 = 0.0
+        bsr_norm = max(0.0, 1.0 - math.log10(bsr) / 6.0)  # log10(1M) = 6
+        bsr_coeff = (bsr_norm - 0.5) * 0.08   # -4% to +4% per month pressure
+    else:
+        bsr_norm  = 0.5
+        bsr_coeff = 0.0
+
+    # ── Competition coefficient ──────────────────────────────────────────────
+    # More sellers = race to bottom = price drops ~1-2% per extra seller
+    competition_coeff = -0.012 * max(0, seller_count - 1)  # -1.2% per extra seller
+
+    # ── Review momentum ──────────────────────────────────────────────────────
+    # Products gaining reviews can hold or slightly raise prices
+    # High rating + many reviews = pricing power
+    review_norm  = min(1.0, math.log10(max(1, review_count)) / 4.0)  # 0–1
+    rating_power = (rating - 3.0) / 2.0 if rating > 0 else 0          # -1.5 to +1
+    review_coeff = review_norm * rating_power * 0.015  # up to +1.5% / month
+
+    # ── Historical trend (if available) ──────────────────────────────────────
+    historical_monthly_change = 0.0
+    trend_confidence_bonus = 0
+    if price_history and len(price_history) >= 3:
+        prices = [p["price"] for p in price_history if p.get("price")]
+        if len(prices) >= 3:
+            # Simple linear regression slope
+            n = len(prices)
+            x_mean = (n - 1) / 2
+            y_mean = sum(prices) / n
+            numerator   = sum((i - x_mean) * (prices[i] - y_mean) for i in range(n))
+            denominator = sum((i - x_mean) ** 2 for i in range(n))
+            if denominator > 0:
+                slope = numerator / denominator  # price change per period
+                # Convert to monthly % change
+                historical_monthly_change = slope / prices[0] if prices[0] > 0 else 0
+            trend_confidence_bonus = 15  # more confident with real data
+
+    # ── Combine coefficients ─────────────────────────────────────────────────
+    if historical_monthly_change != 0:
+        # Weight historical trend 60%, model 40%
+        model_monthly = bsr_coeff + competition_coeff + review_coeff
+        monthly_change_rate = 0.6 * historical_monthly_change + 0.4 * model_monthly
+    else:
+        monthly_change_rate = bsr_coeff + competition_coeff + review_coeff
+
+    # Cap monthly change: Amazon prices rarely move more than ±8% per month
+    monthly_change_rate = max(-0.08, min(0.08, monthly_change_rate))
+
+    # ── Predictions ──────────────────────────────────────────────────────────
+    p30  = round(current_price * (1 + monthly_change_rate),      2)
+    p60  = round(current_price * (1 + monthly_change_rate * 2),  2)
+    p90  = round(current_price * (1 + monthly_change_rate * 3),  2)
+
+    # Ensure prices stay positive
+    p30  = max(0.99, p30)
+    p60  = max(0.99, p60)
+    p90  = max(0.99, p90)
+
+    # ── Confidence interval (±%) ──────────────────────────────────────────────
+    # Less data → wider interval
+    base_uncertainty = 0.08  # ±8% base
+    if bsr: base_uncertainty -= 0.02
+    if review_count > 100: base_uncertainty -= 0.01
+    if price_history and len(price_history) >= 5: base_uncertainty -= 0.02
+    uncertainty = max(0.03, base_uncertainty)
+
+    # ── Confidence score ──────────────────────────────────────────────────────
+    confidence = 55 + trend_confidence_bonus
+    if bsr and bsr > 0: confidence += 10
+    if review_count > 50: confidence += 8
+    if price_history and len(price_history) >= 3: confidence += 12
+    confidence = min(92, confidence)
+
+    # ── Direction label ───────────────────────────────────────────────────────
+    if monthly_change_rate > 0.02:
+        direction = "upward"
+        direction_label = "Price likely to rise"
+        direction_reason = _build_reason(bsr_coeff, competition_coeff, review_coeff, "up")
+    elif monthly_change_rate < -0.02:
+        direction = "downward"
+        direction_label = "Price likely to decrease"
+        direction_reason = _build_reason(bsr_coeff, competition_coeff, review_coeff, "down")
+    else:
+        direction = "stable"
+        direction_label = "Price likely to remain stable"
+        direction_reason = "Competing forces are balanced — no strong movement expected"
+
+    # ── Pricing recommendation ────────────────────────────────────────────────
+    if direction == "downward" and abs(monthly_change_rate) > 0.04:
+        recommendation = f"Consider sourcing now before price drops further. Target entry price: ${p90:.2f}"
+    elif direction == "upward":
+        recommendation = f"Price trending up — list sooner. Predicted ceiling: ${p90:.2f}"
+    else:
+        recommendation = f"Stable pricing environment. Current price ${current_price:.2f} is representative of near-term market."
+
+    result = {
+        "current_price":  current_price,
+        "predictions": {
+            "days_30": {"price": p30, "change_pct": round((p30 - current_price) / current_price * 100, 1),
+                        "low": round(p30 * (1 - uncertainty), 2), "high": round(p30 * (1 + uncertainty), 2)},
+            "days_60": {"price": p60, "change_pct": round((p60 - current_price) / current_price * 100, 1),
+                        "low": round(p60 * (1 - uncertainty), 2), "high": round(p60 * (1 + uncertainty), 2)},
+            "days_90": {"price": p90, "change_pct": round((p90 - current_price) / current_price * 100, 1),
+                        "low": round(p90 * (1 - uncertainty), 2), "high": round(p90 * (1 + uncertainty), 2)},
+        },
+        "direction":         direction,
+        "direction_label":   direction_label,
+        "direction_reason":  direction_reason,
+        "monthly_change_pct": round(monthly_change_rate * 100, 2),
+        "confidence":        confidence,
+        "recommendation":    recommendation,
+        "engine":            "heuristic",
+        "model":             "linear-regression",
+        "model_factors": {
+            "bsr_pressure":      round(bsr_coeff * 100, 2),
+            "competition_pressure": round(competition_coeff * 100, 2),
+            "review_momentum":   round(review_coeff * 100, 2),
+            "historical_trend":  round(historical_monthly_change * 100, 2) if historical_monthly_change else None,
+        },
+    }
+
+    try:
+        from app.services.ml.sklearn_engine import get_engine
+        engine = get_engine()
+        if engine:
+            ml = engine.predict_price_delta(current_price, bsr, rating, review_count, seller_count)
+            result["predictions"] = ml["predictions"]
+            result["monthly_change_pct"] = ml["monthly_change_pct"]
+            result["model_factors"] = {**result["model_factors"], **ml["model_factors"]}
+            result["confidence"] = max(confidence, ml.get("confidence", 70))
+            result["engine"] = "sklearn+heuristic"
+            result["model"] = ml.get("model", "GradientBoostingRegressor")
+            result["model_version"] = ml.get("model_version")
+            d = ml["direction"]
+            result["direction"] = "upward" if d == "up" else "downward" if d == "down" else "stable"
+            result["direction_label"] = ml["direction_label"]
+            result["direction_reason"] = (
+                f"Scikit-learn price model predicts {ml['monthly_change_pct']:+.1f}% over 30 days "
+                f"(blended with BSR/competition signals)."
+            )
+    except Exception as e:
+        print(f"[price_predictor] sklearn blend failed: {e}")
+
+    return result
+
+
+def _build_reason(bsr_c, comp_c, rev_c, direction):
+    factors = []
+    if abs(bsr_c) > 0.01:
+        factors.append("BSR rank pressure" if bsr_c > 0 else "weak sales rank pushing price down")
+    if abs(comp_c) > 0.01:
+        factors.append(f"competition ({abs(comp_c)*100:.1f}% downward pressure)")
+    if abs(rev_c) > 0.005:
+        factors.append("strong review momentum supporting price" if rev_c > 0 else "declining review sentiment")
+    if not factors:
+        return "Marginal pressure from market dynamics"
+    return "Driven by: " + ", ".join(factors)
+
+
+def _empty_prediction(price):
+    return {
+        "current_price": price,
+        "predictions": {
+            "days_30": {"price": price, "change_pct": 0.0, "low": price, "high": price},
+            "days_60": {"price": price, "change_pct": 0.0, "low": price, "high": price},
+            "days_90": {"price": price, "change_pct": 0.0, "low": price, "high": price},
+        },
+        "direction": "stable",
+        "direction_label": "Insufficient data",
+        "direction_reason": "Not enough data to make a prediction",
+        "monthly_change_pct": 0.0,
+        "confidence": 20,
+        "recommendation": "Gather more data by tracking this product over time.",
+        "model_factors": {"bsr_pressure": 0, "competition_pressure": 0, "review_momentum": 0, "historical_trend": None},
     }

app/services/ml/sklearn_engine.py

@@ -1,312 +1,312 @@
-# app/services/ml/sklearn_engine.py
-"""Scikit-learn ML engine for Rankora.
-
-Trains lightweight models on a synthetic Amazon seller dataset at first use.
-Models are real ML (RandomForest, GradientBoosting) — not pure heuristics.
-Falls back gracefully if scikit-learn is unavailable.
-"""
-from __future__ import annotations
-
-import math
-import random
-from typing import Any, Dict, List, Optional, Tuple
-
-_ENGINE: Optional["SklearnEngine"] = None
-
-
-def get_engine() -> Optional["SklearnEngine"]:
-    global _ENGINE
-    if _ENGINE is None:
-        try:
-            _ENGINE = SklearnEngine()
-            _ENGINE.train()
-        except Exception as e:
-            print(f"[sklearn_engine] init failed: {e}")
-            _ENGINE = None
-    return _ENGINE
-
-
-def is_sklearn_available() -> bool:
-    return get_engine() is not None
-
-
-class SklearnEngine:
-    """Singleton trained models for product intelligence."""
-
-    MODEL_VERSION = "1.0.0"
-
-    def __init__(self) -> None:
-        self.fake_review_model = None
-        self.price_model = None
-        self.demand_model = None
-        self.niche_model = None
-        self._ready = False
-
-    def train(self) -> None:
-        import numpy as np
-        from sklearn.ensemble import GradientBoostingRegressor, RandomForestClassifier
-
-        rng = random.Random(42)
-        rows: List[Dict[str, float]] = []
-
-        for _ in range(2500):
-            bsr = rng.choice([rng.randint(50, 5000), rng.randint(5000, 80000), rng.randint(80000, 900000)])
-            rating = round(min(5.0, max(2.0, rng.gauss(4.2, 0.45))), 2)
-            review_count = int(max(0, rng.gauss(bsr / 15, bsr / 40)))
-            monthly_sales = max(1, int(8500 / math.log10(bsr + 10)))
-            seller_count = rng.randint(1, 12)
-            price = round(max(8.0, rng.gauss(28, 14)), 2)
-            is_fba = 1 if rng.random() > 0.25 else 0
-
-            review_ratio = review_count / max(monthly_sales * 12 * 0.04, 1)
-            bsr_norm = max(0.0, 1.0 - math.log10(max(bsr, 1)) / 6.0)
-            rating_perfection = 1.0 if rating >= 4.85 else 0.0
-
-            fake_risk = 0
-            if rating >= 4.9 and review_count > 200:
-                fake_risk += 35
-            if review_ratio > 3.5:
-                fake_risk += 30
-            if bsr > 100_000 and review_count > 80:
-                fake_risk += 25
-            if seller_count == 1 and rating >= 4.8:
-                fake_risk += 15
-            fake_risk = min(100, fake_risk + rng.randint(-8, 8))
-
-            price_delta_30 = (bsr_norm - 0.5) * 8 - seller_count * 0.8 + (rating - 4.0) * 1.2
-            price_delta_30 += rng.gauss(0, 1.5)
-
-            demand_next = monthly_sales * (1.0 + (bsr_norm - 0.4) * 0.06) * (0.95 + rating / 20)
-            demand_next = max(1, int(demand_next + rng.gauss(0, monthly_sales * 0.05)))
-
-            niche = (
-                bsr_norm * 30
-                + min(review_count / 50, 20)
-                + (rating / 5) * 15
-                + min(price / 3, 15)
-                + min(monthly_sales / 100, 20)
-                + (10 if seller_count <= 5 else 3)
-                + (5 if is_fba else 0)
-            )
-            niche = min(100, max(0, niche + rng.gauss(0, 5)))
-
-            rows.append({
-                "rating": rating,
-                "review_count": float(review_count),
-                "log_bsr": math.log10(max(bsr, 1)),
-                "monthly_sales": float(monthly_sales),
-                "seller_count": float(seller_count),
-                "price": price,
-                "is_fba": float(is_fba),
-                "review_ratio": review_ratio,
-                "bsr_norm": bsr_norm,
-                "rating_perfection": rating_perfection,
-                "fake_risk": float(fake_risk),
-                "price_delta_30": price_delta_30,
-                "demand_next": float(demand_next),
-                "niche_score": niche,
-            })
-
-        X_fake = np.array([[r["rating"], r["review_count"], r["log_bsr"], r["monthly_sales"],
-                            r["seller_count"], r["review_ratio"], r["rating_perfection"]] for r in rows])
-        y_fake = np.array([1 if r["fake_risk"] >= 45 else 0 for r in rows])
-
-        X_price = np.array([[r["price"], r["log_bsr"], r["rating"], r["review_count"],
-                             r["seller_count"], r["bsr_norm"]] for r in rows])
-        y_price = np.array([r["price_delta_30"] for r in rows])
-
-        X_demand = np.array([[r["monthly_sales"], r["log_bsr"], r["rating"], r["review_count"],
-                              r["price"], r["bsr_norm"]] for r in rows])
-        y_demand = np.array([r["demand_next"] for r in rows])
-
-        X_niche = np.array([[r["bsr_norm"], r["review_count"], r["rating"], r["price"],
-                             r["monthly_sales"], r["seller_count"], r["is_fba"]] for r in rows])
-        y_niche = np.array([r["niche_score"] for r in rows])
-
-        self.fake_review_model = RandomForestClassifier(n_estimators=80, max_depth=8, random_state=42)
-        self.fake_review_model.fit(X_fake, y_fake)
-
-        self.price_model = GradientBoostingRegressor(n_estimators=60, max_depth=4, random_state=42)
-        self.price_model.fit(X_price, y_price)
-
-        self.demand_model = GradientBoostingRegressor(n_estimators=60, max_depth=4, random_state=42)
-        self.demand_model.fit(X_demand, y_demand)
-
-        self.niche_model = GradientBoostingRegressor(n_estimators=60, max_depth=4, random_state=42)
-        self.niche_model.fit(X_niche, y_niche)
-
-        self._ready = True
-
-    def _features(
-        self,
-        review_count: int,
-        rating: float,
-        bsr: Optional[int],
-        monthly_sales: Optional[int],
-        seller_count: int,
-        price: float = 0.0,
-        is_fba: bool = False,
-    ) -> Tuple[Any, ...]:
-        import numpy as np
-
-        bsr_val = bsr or 500_000
-        ms = monthly_sales or 1
-        log_bsr = math.log10(max(bsr_val, 1))
-        bsr_norm = max(0.0, 1.0 - log_bsr / 6.0)
-        review_ratio = review_count / max(ms * 12 * 0.04, 1)
-        rating_perfection = 1.0 if rating >= 4.85 else 0.0
-
-        fake = np.array([[rating, review_count, log_bsr, ms, seller_count, review_ratio, rating_perfection]])
-        price_f = np.array([[price or 24.0, log_bsr, rating, review_count, seller_count, bsr_norm]])
-        demand_f = np.array([[ms, log_bsr, rating, review_count, price or 24.0, bsr_norm]])
-        niche_f = np.array([[bsr_norm, review_count, rating, price or 24.0, ms, seller_count, 1.0 if is_fba else 0.0]])
-        return fake, price_f, demand_f, niche_f, bsr_norm, review_ratio
-
-    def predict_fake_review_risk(
-        self,
-        review_count: int,
-        rating: float,
-        bsr: Optional[int],
-        monthly_sales: Optional[int],
-        seller_count: int,
-    ) -> Dict[str, Any]:
-        import numpy as np
-
-        fake_f, _, _, _, _, review_ratio = self._features(
-            review_count, rating, bsr, monthly_sales, seller_count
-        )
-        proba = self.fake_review_model.predict_proba(fake_f)[0]
-        risk_class = int(self.fake_review_model.predict(fake_f)[0])
-        risk_score = int(min(100, max(0, proba[1] * 100 if len(proba) > 1 else proba[0] * 100)))
-        if risk_class == 0:
-            risk_score = min(risk_score, 40)
-
-        if risk_score >= 65:
-            level = "very_high"
-        elif risk_score >= 45:
-            level = "high"
-        elif risk_score >= 25:
-            level = "medium"
-        else:
-            level = "low"
-
-        return {
-            "risk_score": risk_score,
-            "risk_level": level,
-            "trust_score": 100 - risk_score,
-            "confidence": 78,
-            "model": "RandomForestClassifier",
-            "engine": "sklearn",
-            "model_version": self.MODEL_VERSION,
-            "features_used": ["rating", "review_count", "log_bsr", "monthly_sales", "seller_count", "review_ratio"],
-            "review_ratio": round(review_ratio, 2),
-            "risk_class": risk_class,
-        }
-
-    def predict_price_delta(
-        self,
-        current_price: float,
-        bsr: Optional[int],
-        rating: float,
-        review_count: int,
-        seller_count: int,
-    ) -> Dict[str, Any]:
-        _, price_f, _, _, bsr_norm, _ = self._features(
-            review_count, rating, bsr, None, seller_count, current_price
-        )
-        delta_30 = float(self.price_model.predict(price_f)[0])
-        delta_60 = delta_30 * 1.65
-        delta_90 = delta_30 * 2.35
-
-        def point(days: int, delta: float) -> Dict[str, float]:
-            pct = delta
-            pred = round(max(0.01, current_price * (1 + pct / 100)), 2)
-            spread = abs(pred * 0.06)
-            return {
-                "price": pred,
-                "change_pct": round(pct, 2),
-                "low": round(max(0.01, pred - spread), 2),
-                "high": round(pred + spread, 2),
-            }
-
-        direction = "up" if delta_30 > 1.5 else "down" if delta_30 < -1.5 else "stable"
-        labels = {"up": "Trending Up", "down": "Trending Down", "stable": "Stable"}
-
-        return {
-            "monthly_change_pct": round(delta_30, 2),
-            "direction": direction,
-            "direction_label": labels[direction],
-            "confidence": 72,
-            "model": "GradientBoostingRegressor",
-            "engine": "sklearn",
-            "model_version": self.MODEL_VERSION,
-            "predictions": {
-                "days_30": point(30, delta_30),
-                "days_60": point(60, delta_60),
-                "days_90": point(90, delta_90),
-            },
-            "model_factors": {
-                "bsr_pressure": round((bsr_norm - 0.5) * 100, 1),
-                "competition_pressure": round(-seller_count * 12, 1),
-                "review_momentum": round((rating - 3.5) * 20, 1),
-            },
-        }
-
-    def predict_demand(
-        self,
-        bsr: Optional[int],
-        monthly_sales: int,
-        rating: float,
-        review_count: int,
-        price: float,
-    ) -> Dict[str, Any]:
-        _, _, demand_f, _, _, _ = self._features(
-            review_count, rating, bsr, monthly_sales, 1, price
-        )
-        next_units = max(1, int(self.demand_model.predict(demand_f)[0]))
-        trend = "growing" if next_units > monthly_sales * 1.05 else "declining" if next_units < monthly_sales * 0.95 else "stable"
-
-        return {
-            "next_month_units": next_units,
-            "trend": trend,
-            "confidence": 70,
-            "model": "GradientBoostingRegressor",
-            "engine": "sklearn",
-            "model_version": self.MODEL_VERSION,
-        }
-
-    def predict_niche_score(
-        self,
-        bsr: Optional[int],
-        review_count: int,
-        rating: float,
-        price: float,
-        monthly_sales: int,
-        seller_count: int,
-        is_fba: bool,
-    ) -> Dict[str, Any]:
-        _, _, _, niche_f, _, _ = self._features(
-            review_count, rating, bsr, monthly_sales, seller_count, price, is_fba
-        )
-        score = int(min(100, max(0, round(float(self.niche_model.predict(niche_f)[0])))))
-
-        if score >= 80:
-            grade, verdict, action = "A", "Excellent niche opportunity", "Prioritize sourcing and listing tests"
-        elif score >= 60:
-            grade, verdict, action = "B", "Good opportunity with manageable risk", "Validate suppliers and differentiation"
-        elif score >= 40:
-            grade, verdict, action = "C", "Average — needs a clear USP", "Find a sub-niche or bundle angle"
-        elif score >= 20:
-            grade, verdict, action = "D", "Difficult market entry", "Only proceed with strong differentiation"
-        else:
-            grade, verdict, action = "F", "Not recommended", "Look for better opportunities"
-
-        return {
-            "niche_score": score,
-            "grade": grade,
-            "verdict": verdict,
-            "action": action,
-            "model": "GradientBoostingRegressor",
-            "engine": "sklearn",
-            "model_version": self.MODEL_VERSION,
-        }
+# app/services/ml/sklearn_engine.py
+"""Scikit-learn ML engine for Rankora.
+
+Trains lightweight models on a synthetic Amazon seller dataset at first use.
+Models are real ML (RandomForest, GradientBoosting) — not pure heuristics.
+Falls back gracefully if scikit-learn is unavailable.
+"""
+from __future__ import annotations
+
+import math
+import random
+from typing import Any, Dict, List, Optional, Tuple
+
+_ENGINE: Optional["SklearnEngine"] = None
+
+
+def get_engine() -> Optional["SklearnEngine"]:
+    global _ENGINE
+    if _ENGINE is None:
+        try:
+            _ENGINE = SklearnEngine()
+            _ENGINE.train()
+        except Exception as e:
+            print(f"[sklearn_engine] init failed: {e}")
+            _ENGINE = None
+    return _ENGINE
+
+
+def is_sklearn_available() -> bool:
+    return get_engine() is not None
+
+
+class SklearnEngine:
+    """Singleton trained models for product intelligence."""
+
+    MODEL_VERSION = "1.0.0"
+
+    def __init__(self) -> None:
+        self.fake_review_model = None
+        self.price_model = None
+        self.demand_model = None
+        self.niche_model = None
+        self._ready = False
+
+    def train(self) -> None:
+        import numpy as np
+        from sklearn.ensemble import GradientBoostingRegressor, RandomForestClassifier
+
+        rng = random.Random(42)
+        rows: List[Dict[str, float]] = []
+
+        for _ in range(2500):
+            bsr = rng.choice([rng.randint(50, 5000), rng.randint(5000, 80000), rng.randint(80000, 900000)])
+            rating = round(min(5.0, max(2.0, rng.gauss(4.2, 0.45))), 2)
+            review_count = int(max(0, rng.gauss(bsr / 15, bsr / 40)))
+            monthly_sales = max(1, int(8500 / math.log10(bsr + 10)))
+            seller_count = rng.randint(1, 12)
+            price = round(max(8.0, rng.gauss(28, 14)), 2)
+            is_fba = 1 if rng.random() > 0.25 else 0
+
+            review_ratio = review_count / max(monthly_sales * 12 * 0.04, 1)
+            bsr_norm = max(0.0, 1.0 - math.log10(max(bsr, 1)) / 6.0)
+            rating_perfection = 1.0 if rating >= 4.85 else 0.0
+
+            fake_risk = 0
+            if rating >= 4.9 and review_count > 200:
+                fake_risk += 35
+            if review_ratio > 3.5:
+                fake_risk += 30
+            if bsr > 100_000 and review_count > 80:
+                fake_risk += 25
+            if seller_count == 1 and rating >= 4.8:
+                fake_risk += 15
+            fake_risk = min(100, fake_risk + rng.randint(-8, 8))
+
+            price_delta_30 = (bsr_norm - 0.5) * 8 - seller_count * 0.8 + (rating - 4.0) * 1.2
+            price_delta_30 += rng.gauss(0, 1.5)
+
+            demand_next = monthly_sales * (1.0 + (bsr_norm - 0.4) * 0.06) * (0.95 + rating / 20)
+            demand_next = max(1, int(demand_next + rng.gauss(0, monthly_sales * 0.05)))
+
+            niche = (
+                bsr_norm * 30
+                + min(review_count / 50, 20)
+                + (rating / 5) * 15
+                + min(price / 3, 15)
+                + min(monthly_sales / 100, 20)
+                + (10 if seller_count <= 5 else 3)
+                + (5 if is_fba else 0)
+            )
+            niche = min(100, max(0, niche + rng.gauss(0, 5)))
+
+            rows.append({
+                "rating": rating,
+                "review_count": float(review_count),
+                "log_bsr": math.log10(max(bsr, 1)),
+                "monthly_sales": float(monthly_sales),
+                "seller_count": float(seller_count),
+                "price": price,
+                "is_fba": float(is_fba),
+                "review_ratio": review_ratio,
+                "bsr_norm": bsr_norm,
+                "rating_perfection": rating_perfection,
+                "fake_risk": float(fake_risk),
+                "price_delta_30": price_delta_30,
+                "demand_next": float(demand_next),
+                "niche_score": niche,
+            })
+
+        X_fake = np.array([[r["rating"], r["review_count"], r["log_bsr"], r["monthly_sales"],
+                            r["seller_count"], r["review_ratio"], r["rating_perfection"]] for r in rows])
+        y_fake = np.array([1 if r["fake_risk"] >= 45 else 0 for r in rows])
+
+        X_price = np.array([[r["price"], r["log_bsr"], r["rating"], r["review_count"],
+                             r["seller_count"], r["bsr_norm"]] for r in rows])
+        y_price = np.array([r["price_delta_30"] for r in rows])
+
+        X_demand = np.array([[r["monthly_sales"], r["log_bsr"], r["rating"], r["review_count"],
+                              r["price"], r["bsr_norm"]] for r in rows])
+        y_demand = np.array([r["demand_next"] for r in rows])
+
+        X_niche = np.array([[r["bsr_norm"], r["review_count"], r["rating"], r["price"],
+                             r["monthly_sales"], r["seller_count"], r["is_fba"]] for r in rows])
+        y_niche = np.array([r["niche_score"] for r in rows])
+
+        self.fake_review_model = RandomForestClassifier(n_estimators=80, max_depth=8, random_state=42)
+        self.fake_review_model.fit(X_fake, y_fake)
+
+        self.price_model = GradientBoostingRegressor(n_estimators=60, max_depth=4, random_state=42)
+        self.price_model.fit(X_price, y_price)
+
+        self.demand_model = GradientBoostingRegressor(n_estimators=60, max_depth=4, random_state=42)
+        self.demand_model.fit(X_demand, y_demand)
+
+        self.niche_model = GradientBoostingRegressor(n_estimators=60, max_depth=4, random_state=42)
+        self.niche_model.fit(X_niche, y_niche)
+
+        self._ready = True
+
+    def _features(
+        self,
+        review_count: int,
+        rating: float,
+        bsr: Optional[int],
+        monthly_sales: Optional[int],
+        seller_count: int,
+        price: float = 0.0,
+        is_fba: bool = False,
+    ) -> Tuple[Any, ...]:
+        import numpy as np
+
+        bsr_val = bsr or 500_000
+        ms = monthly_sales or 1
+        log_bsr = math.log10(max(bsr_val, 1))
+        bsr_norm = max(0.0, 1.0 - log_bsr / 6.0)
+        review_ratio = review_count / max(ms * 12 * 0.04, 1)
+        rating_perfection = 1.0 if rating >= 4.85 else 0.0
+
+        fake = np.array([[rating, review_count, log_bsr, ms, seller_count, review_ratio, rating_perfection]])
+        price_f = np.array([[price or 24.0, log_bsr, rating, review_count, seller_count, bsr_norm]])
+        demand_f = np.array([[ms, log_bsr, rating, review_count, price or 24.0, bsr_norm]])
+        niche_f = np.array([[bsr_norm, review_count, rating, price or 24.0, ms, seller_count, 1.0 if is_fba else 0.0]])
+        return fake, price_f, demand_f, niche_f, bsr_norm, review_ratio
+
+    def predict_fake_review_risk(
+        self,
+        review_count: int,
+        rating: float,
+        bsr: Optional[int],
+        monthly_sales: Optional[int],
+        seller_count: int,
+    ) -> Dict[str, Any]:
+        import numpy as np
+
+        fake_f, _, _, _, _, review_ratio = self._features(
+            review_count, rating, bsr, monthly_sales, seller_count
+        )
+        proba = self.fake_review_model.predict_proba(fake_f)[0]
+        risk_class = int(self.fake_review_model.predict(fake_f)[0])
+        risk_score = int(min(100, max(0, proba[1] * 100 if len(proba) > 1 else proba[0] * 100)))
+        if risk_class == 0:
+            risk_score = min(risk_score, 40)
+
+        if risk_score >= 65:
+            level = "very_high"
+        elif risk_score >= 45:
+            level = "high"
+        elif risk_score >= 25:
+            level = "medium"
+        else:
+            level = "low"
+
+        return {
+            "risk_score": risk_score,
+            "risk_level": level,
+            "trust_score": 100 - risk_score,
+            "confidence": 78,
+            "model": "RandomForestClassifier",
+            "engine": "sklearn",
+            "model_version": self.MODEL_VERSION,
+            "features_used": ["rating", "review_count", "log_bsr", "monthly_sales", "seller_count", "review_ratio"],
+            "review_ratio": round(review_ratio, 2),
+            "risk_class": risk_class,
+        }
+
+    def predict_price_delta(
+        self,
+        current_price: float,
+        bsr: Optional[int],
+        rating: float,
+        review_count: int,
+        seller_count: int,
+    ) -> Dict[str, Any]:
+        _, price_f, _, _, bsr_norm, _ = self._features(
+            review_count, rating, bsr, None, seller_count, current_price
+        )
+        delta_30 = float(self.price_model.predict(price_f)[0])
+        delta_60 = delta_30 * 1.65
+        delta_90 = delta_30 * 2.35
+
+        def point(days: int, delta: float) -> Dict[str, float]:
+            pct = delta
+            pred = round(max(0.01, current_price * (1 + pct / 100)), 2)
+            spread = abs(pred * 0.06)
+            return {
+                "price": pred,
+                "change_pct": round(pct, 2),
+                "low": round(max(0.01, pred - spread), 2),
+                "high": round(pred + spread, 2),
+            }
+
+        direction = "up" if delta_30 > 1.5 else "down" if delta_30 < -1.5 else "stable"
+        labels = {"up": "Trending Up", "down": "Trending Down", "stable": "Stable"}
+
+        return {
+            "monthly_change_pct": round(delta_30, 2),
+            "direction": direction,
+            "direction_label": labels[direction],
+            "confidence": 72,
+            "model": "GradientBoostingRegressor",
+            "engine": "sklearn",
+            "model_version": self.MODEL_VERSION,
+            "predictions": {
+                "days_30": point(30, delta_30),
+                "days_60": point(60, delta_60),
+                "days_90": point(90, delta_90),
+            },
+            "model_factors": {
+                "bsr_pressure": round((bsr_norm - 0.5) * 100, 1),
+                "competition_pressure": round(-seller_count * 12, 1),
+                "review_momentum": round((rating - 3.5) * 20, 1),
+            },
+        }
+
+    def predict_demand(
+        self,
+        bsr: Optional[int],
+        monthly_sales: int,
+        rating: float,
+        review_count: int,
+        price: float,
+    ) -> Dict[str, Any]:
+        _, _, demand_f, _, _, _ = self._features(
+            review_count, rating, bsr, monthly_sales, 1, price
+        )
+        next_units = max(1, int(self.demand_model.predict(demand_f)[0]))
+        trend = "growing" if next_units > monthly_sales * 1.05 else "declining" if next_units < monthly_sales * 0.95 else "stable"
+
+        return {
+            "next_month_units": next_units,
+            "trend": trend,
+            "confidence": 70,
+            "model": "GradientBoostingRegressor",
+            "engine": "sklearn",
+            "model_version": self.MODEL_VERSION,
+        }
+
+    def predict_niche_score(
+        self,
+        bsr: Optional[int],
+        review_count: int,
+        rating: float,
+        price: float,
+        monthly_sales: int,
+        seller_count: int,
+        is_fba: bool,
+    ) -> Dict[str, Any]:
+        _, _, _, niche_f, _, _ = self._features(
+            review_count, rating, bsr, monthly_sales, seller_count, price, is_fba
+        )
+        score = int(min(100, max(0, round(float(self.niche_model.predict(niche_f)[0])))))
+
+        if score >= 80:
+            grade, verdict, action = "A", "Excellent niche opportunity", "Prioritize sourcing and listing tests"
+        elif score >= 60:
+            grade, verdict, action = "B", "Good opportunity with manageable risk", "Validate suppliers and differentiation"
+        elif score >= 40:
+            grade, verdict, action = "C", "Average — needs a clear USP", "Find a sub-niche or bundle angle"
+        elif score >= 20:
+            grade, verdict, action = "D", "Difficult market entry", "Only proceed with strong differentiation"
+        else:
+            grade, verdict, action = "F", "Not recommended", "Look for better opportunities"
+
+        return {
+            "niche_score": score,
+            "grade": grade,
+            "verdict": verdict,
+            "action": action,
+            "model": "GradientBoostingRegressor",
+            "engine": "sklearn",
+            "model_version": self.MODEL_VERSION,
+        }

app/services/product_service.py

@@ -1,418 +1,504 @@
-"""Shared product fetch, persist, and response building."""
-import uuid
-from datetime import datetime, timezone
-from typing import Optional
-
-from sqlalchemy.orm import Session
-
-from app.models.product import Product, PriceHistory
-from app.services.amazon.product_scraper import scrape_amazon_product
-from app.services.amazon.sales_estimator import estimate_monthly_sales, calculate_opportunity_score
-from app.services.analytics.tracking_service import check_alerts
-from app.services.analytics.buy_box_rotation import estimate_buy_box_rotation
-from app.services.analytics.buy_box_history import (
-    record_buy_box_snapshot,
-    get_buy_box_snapshots,
-    rotation_from_snapshots,
-    build_buy_box_timeline,
-    build_historical_charts_payload,
-)
-
-
-def _buy_box_data_from_product(product: Product) -> dict:
-    has_bb = product.has_buy_box if product.has_buy_box is not None else True
-    is_fba = product.buy_box_is_fba
-    seller_count = product.seller_count or 1
-    fba_sellers = 0
-    fbm_sellers = 0
-    if is_fba is True:
-        fba_sellers = max(1, seller_count - 1) if seller_count > 1 else 1
-        fbm_sellers = max(0, seller_count - fba_sellers)
-    elif is_fba is False:
-        fbm_sellers = max(1, seller_count)
-        fba_sellers = max(0, seller_count - fbm_sellers)
-    return {
-        "buy_box_winner": product.buy_box_winner,
-        "buy_box_price": float(product.buy_box_price) if product.buy_box_price else None,
-        "buy_box_is_fba": is_fba,
-        "buy_box_is_prime": product.is_prime,
-        "is_amazon_sold": product.is_amazon_sold or False,
-        "seller_count": seller_count,
-        "fba_seller_count": fba_sellers,
-        "fbm_seller_count": fbm_sellers,
-        "has_buy_box": has_bb,
-        "other_sellers": [],
-        "offers_source": product.last_data_source,
-    }
-
-
-def build_buy_box_analysis(
-    data: dict,
-    price: float,
-    rating: float,
-    reviews: int,
-    rotation: Optional[dict] = None,
-    history_timeline: Optional[list] = None,
-) -> dict:
-    """Build complete buy box analysis from scraped + calculated data."""
-    buy_box_winner = data.get("buy_box_winner") or "Unknown"
-    buy_box_price = data.get("buy_box_price") or price
-    is_fba = data.get("buy_box_is_fba")
-    is_prime = data.get("buy_box_is_prime", True)
-    is_amazon = data.get("is_amazon_sold", False)
-    seller_count = data.get("seller_count", 1)
-    has_buy_box = data.get("has_buy_box", True)
-    fba_seller_count = data.get("fba_seller_count")
-    fbm_seller_count = data.get("fbm_seller_count")
-    if fba_seller_count is None and fbm_seller_count is None:
-        if is_fba is True:
-            fba_seller_count = max(1, seller_count)
-            fbm_seller_count = max(0, seller_count - fba_seller_count)
-        elif is_fba is False:
-            fbm_seller_count = max(1, seller_count)
-            fba_seller_count = max(0, seller_count - fbm_seller_count)
-        else:
-            fba_seller_count = None
-            fbm_seller_count = None
-
-    score = 0
-    factors = []
-
-    if price and buy_box_price:
-        price_diff_pct = abs(price - buy_box_price) / buy_box_price * 100
-        if price_diff_pct <= 2:
-            score += 25
-            factors.append({"factor": "Price", "status": "Competitive ✓", "color": "#10B981",
-                           "detail": f"${price} is within 2% of buy box price (${buy_box_price})"})
-        elif price_diff_pct <= 10:
-            score += 15
-            factors.append({"factor": "Price", "status": "Close", "color": "#F59E0B",
-                           "detail": f"${price} is {price_diff_pct:.1f}% from buy box price (${buy_box_price})"})
-        else:
-            score += 5
-            factors.append({"factor": "Price", "status": "Too High", "color": "#EF4444",
-                           "detail": f"${price} is {price_diff_pct:.1f}% above buy box price — lower price to compete"})
-    else:
-        score += 15
-        factors.append({"factor": "Price", "status": "Unknown", "color": "#9CA3AF", "detail": "Could not determine price gap"})
-
-    if is_fba is True:
-        score += 30
-        factors.append({"factor": "Fulfillment", "status": "FBA ✓", "color": "#10B981",
-                       "detail": "FBA strongly favored — Amazon prefers its own fulfillment"})
-    elif is_fba is False:
-        score += 5
-        factors.append({"factor": "Fulfillment", "status": "FBM ✗", "color": "#EF4444",
-                       "detail": "FBM sellers rarely win buy box — switch to FBA"})
-    else:
-        score += 10
-        factors.append({"factor": "Fulfillment", "status": "Unknown", "color": "#9CA3AF",
-                       "detail": "Fulfillment type unclear — refresh product data"})
-
-    if is_prime:
-        score += 20
-        factors.append({"factor": "Prime Badge", "status": "Eligible ✓", "color": "#10B981",
-                       "detail": "Prime eligible — required for consistent buy box wins"})
-    else:
-        factors.append({"factor": "Prime Badge", "status": "Not Eligible ✗", "color": "#EF4444",
-                       "detail": "No Prime = very low chance of winning buy box"})
-
-    if rating and rating >= 4.5:
-        score += 15
-        factors.append({"factor": "Seller Rating", "status": "Excellent ✓", "color": "#10B981",
-                       "detail": f"{rating}★ — Amazon heavily favors high-rated sellers"})
-    elif rating and rating >= 4.0:
-        score += 10
-        factors.append({"factor": "Seller Rating", "status": "Good", "color": "#F59E0B",
-                       "detail": f"{rating}★ — acceptable but not ideal for buy box"})
-    else:
-        score += 3
-        factors.append({"factor": "Seller Rating", "status": "Needs Work ✗", "color": "#EF4444",
-                       "detail": f"{rating or 'Unknown'}★ — low rating significantly hurts buy box eligibility"})
-
-    if seller_count <= 2:
-        score += 10
-        factors.append({"factor": "Competition", "status": f"Low ({seller_count} sellers)", "color": "#10B981",
-                       "detail": "Few sellers = easier to win and keep buy box"})
-    elif seller_count <= 5:
-        score += 6
-        factors.append({"factor": "Competition", "status": f"Medium ({seller_count} sellers)", "color": "#F59E0B",
-                       "detail": f"{seller_count} competing sellers — maintain competitive price"})
-    else:
-        score += 2
-        factors.append({"factor": "Competition", "status": f"High ({seller_count}+ sellers)", "color": "#EF4444",
-                       "detail": f"{seller_count}+ sellers competing — very hard to win consistently"})
-
-    score = min(score, 100)
-
-    if score >= 75:
-        verdict, verdict_color = "Strong Buy Box Candidate", "#10B981"
-    elif score >= 50:
-        verdict, verdict_color = "Moderate Chance", "#F59E0B"
-    elif score >= 25:
-        verdict, verdict_color = "Low Chance", "#FB923C"
-    else:
-        verdict, verdict_color = "Unlikely to Win", "#EF4444"
-
-    owner_badge = "🟡 3rd Party"
-    owner_color = "#F59E0B"
-    if is_amazon:
-        owner_badge = "🔵 Amazon"
-        owner_color = "#3B82F6"
-    elif is_fba is True:
-        owner_badge = "🟢 FBA Seller"
-        owner_color = "#10B981"
-    elif is_fba is False:
-        owner_badge = "🟠 FBM Seller"
-        owner_color = "#F59E0B"
-
-    rotation_data = {
-        **data,
-        "buy_box_winner": buy_box_winner,
-        "buy_box_price": buy_box_price,
-        "buy_box_is_fba": is_fba,
-        "seller_count": seller_count,
-        "has_buy_box": has_buy_box,
-        "price": price,
-    }
-    if rotation is None:
-        rotation = estimate_buy_box_rotation(rotation_data) if has_buy_box else {"sellers": [], "eligible_fba": 0, "eligible_fbm": 0}
-        rotation["source"] = "estimated"
-
-    return {
-        "score": score,
-        "verdict": verdict,
-        "verdict_color": verdict_color,
-        "factors": factors,
-        "has_buy_box": has_buy_box,
-        "current_winner": buy_box_winner if has_buy_box else None,
-        "current_winner_badge": owner_badge if has_buy_box else "No Buy Box",
-        "current_winner_color": owner_color,
-        "buy_box_price": buy_box_price if has_buy_box else None,
-        "seller_count": seller_count,
-        "fba_seller_count": fba_seller_count,
-        "fbm_seller_count": fbm_seller_count,
-        "is_amazon_sold": is_amazon,
-        "is_fba": is_fba,
-        "is_prime": is_prime,
-        "tips": [
-            "Price within 1-2% of the current buy box price",
-            "Always use FBA — Amazon strongly favors it",
-            "Maintain seller feedback score above 95%",
-            "Keep order defect rate below 1%",
-            "Respond to customer messages within 24 hours",
-        ],
-        "other_sellers": data.get("other_sellers", []),
-        "rotation": rotation,
-        "history_timeline": history_timeline or [],
-    }
-
-
-def persist_scrape(db: Session, product: Optional[Product], asin: str, data: dict) -> Product:
-    if not product:
-        product = Product(
-            id=str(uuid.uuid4()),
-            asin=asin,
-            title=data["title"],
-            brand=data["brand"],
-            upc=data.get("upc"),
-            category=data["category"],
-            image_url=data["image_url"],
-            amazon_url=data["amazon_url"],
-            is_prime=data["is_prime"],
-        )
-        db.add(product)
-        db.flush()
-    else:
-        product.title = data["title"]
-        product.brand = data["brand"]
-        product.upc = data.get("upc") or product.upc
-        product.category = data.get("category") or product.category
-        product.image_url = data.get("image_url") or product.image_url
-        product.is_prime = data.get("is_prime", product.is_prime)
-
-    product.seller_count = data.get("seller_count", 1)
-    product.buy_box_winner = data.get("buy_box_winner")
-    product.buy_box_price = data.get("buy_box_price")
-    product.buy_box_is_fba = data.get("buy_box_is_fba") if "buy_box_is_fba" in data else product.buy_box_is_fba
-    product.has_buy_box = data.get("has_buy_box", True)
-    product.is_amazon_sold = data.get("is_amazon_sold", False)
-    if data.get("package_weight_lbs") is not None:
-        product.package_weight_lbs = data.get("package_weight_lbs")
-    product.last_data_source = data.get("data_source", "live")
-    product.last_synced_at = datetime.now(timezone.utc)
-
-    history = PriceHistory(
-        id=str(uuid.uuid4()),
-        product_id=str(product.id),
-        price=data["price"],
-        bsr=data["bsr"],
-        rating=data["rating"],
-        review_count=data["review_count"],
-        in_stock=data["in_stock"],
-    )
-    db.add(history)
-    record_buy_box_snapshot(db, str(product.id), data)
-    db.commit()
-    db.refresh(product)
-
-    if data.get("price"):
-        check_alerts(db, asin, float(data["price"]), data.get("bsr"))
-
-    return product
-
-
-def build_response(db: Session, product: Product, data_source: str = "cached") -> dict:
-    history = (
-        db.query(PriceHistory)
-        .filter(PriceHistory.product_id == product.id)
-        .order_by(PriceHistory.recorded_at.desc())
-        .limit(180)
-        .all()
-    )
-    latest = history[0] if history else None
-    sales_data = estimate_monthly_sales(latest.bsr if latest else 0, product.category or "")
-
-    seller_count = product.seller_count or 1
-    opportunity_score = None
-    if latest and sales_data["monthly_units"]:
-        opportunity_score = calculate_opportunity_score(
-            bsr=latest.bsr or 0,
-            review_count=latest.review_count or 0,
-            monthly_sales=sales_data["monthly_units"],
-            seller_count=seller_count,
-        )
-
-    price = float(latest.price) if latest and latest.price else None
-    rating = float(latest.rating) if latest and latest.rating else None
-    reviews = latest.review_count if latest else 0
-
-    bb_data = _buy_box_data_from_product(product)
-    snapshots = get_buy_box_snapshots(db, str(product.id), days=90)
-    rotation = rotation_from_snapshots(snapshots, range_days=30, fallback_data={**bb_data, "price": price})
-    history_timeline = build_buy_box_timeline(snapshots, range_days=30)
-    price_history_rows = [
-        {
-            "price": float(h.price) if h.price else None,
-            "bsr": h.bsr,
-            "rating": float(h.rating) if h.rating else None,
-            "review_count": h.review_count,
-            "recorded_at": h.recorded_at.isoformat(),
-        }
-        for h in reversed(history)
-    ]
-    historical_charts = build_historical_charts_payload(
-        snapshots,
-        price_history_rows,
-        category=product.category or "default",
-        range_days=365,
-        weight_lbs=float(product.package_weight_lbs) if product.package_weight_lbs else 1.0,
-    )
-
-    buy_box = build_buy_box_analysis(
-        bb_data,
-        price=price or 25,
-        rating=rating or 4.0,
-        reviews=reviews or 100,
-        rotation=rotation,
-        history_timeline=history_timeline,
-    )
-
-    source = product.last_data_source or data_source
-    last_synced = product.last_synced_at.isoformat() if product.last_synced_at else None
-
-    return {
-        "asin": product.asin,
-        "title": product.title,
-        "brand": product.brand,
-        "upc": product.upc,
-        "category": product.category,
-        "image_url": product.image_url,
-        "amazon_url": product.amazon_url,
-        "is_prime": product.is_prime,
-        "current_price": price,
-        "current_bsr": latest.bsr if latest else None,
-        "current_rating": rating,
-        "current_review_count": latest.review_count if latest else None,
-        "in_stock": latest.in_stock if latest else None,
-        "sales_estimate_monthly": sales_data["monthly_units"],
-        "revenue_estimate_monthly": round(sales_data["monthly_units"] * price, 2) if sales_data["monthly_units"] and price else None,
-        "opportunity_score": opportunity_score,
-        "price_history": price_history_rows,
-        "buy_box": buy_box,
-        "buy_box_history": {
-            "snapshot_count": len(snapshots),
-            "source": rotation.get("source", "estimated"),
-            "timeline": history_timeline,
-            "snapshots": historical_charts.get("buy_box_price_series", []),
-            "charts": historical_charts,
-        },
-        "historical_charts": historical_charts,
-        "package_weight_lbs": float(product.package_weight_lbs) if product.package_weight_lbs else None,
-        "data_source": source,
-        "last_synced_at": last_synced,
-    }
-
-
-def fetch_and_sync_product(db: Session, asin: str, force: bool = False) -> dict:
-    product = db.query(Product).filter(Product.asin == asin).first()
-    needs_refresh = force
-
-    if not needs_refresh and product and product.last_synced_at:
-        last_synced = product.last_synced_at
-        if last_synced.tzinfo is None:
-            last_synced = last_synced.replace(tzinfo=timezone.utc)
-        age_hours = (datetime.now(timezone.utc) - last_synced).total_seconds() / 3600
-        needs_refresh = age_hours > 6
-
-    if not needs_refresh and product:
-        return build_response(db, product, "cached")
-
-    data = scrape_amazon_product(asin)
-    if not data:
-        if product:
-            resp = build_response(db, product, "cached")
-            resp["data_source"] = product.last_data_source or "cached"
-            return resp
-        return None
-
-    try:
-        product = persist_scrape(db, product, asin, data)
-        return build_response(db, product, data.get("data_source", "live"))
-    except Exception as e:
-        db.rollback()
-        print(f"[product_service] DB error: {e}")
-        sales_data = estimate_monthly_sales(data.get("bsr") or 0, data.get("category") or "")
-        opp = calculate_opportunity_score(
-            bsr=data.get("bsr") or 0,
-            review_count=data.get("review_count") or 0,
-            monthly_sales=sales_data["monthly_units"],
-            seller_count=data.get("seller_count", 1),
-        ) if sales_data["monthly_units"] else None
-        buy_box = build_buy_box_analysis(
-            data,
-            price=data.get("price") or 25,
-            rating=data.get("rating") or 4.0,
-            reviews=data.get("review_count") or 100,
-        )
-        return {
-            "asin": asin,
-            "title": data["title"],
-            "brand": data["brand"],
-            "category": data["category"],
-            "image_url": data["image_url"],
-            "amazon_url": data["amazon_url"],
-            "is_prime": data.get("is_prime"),
-            "current_price": data["price"],
-            "current_bsr": data["bsr"],
-            "current_rating": data["rating"],
-            "current_review_count": data["review_count"],
-            "in_stock": data["in_stock"],
-            "sales_estimate_monthly": sales_data["monthly_units"],
-            "revenue_estimate_monthly": round(sales_data["monthly_units"] * (data["price"] or 0), 2) if sales_data["monthly_units"] and data["price"] else None,
-            "opportunity_score": opp,
-            "price_history": [],
-            "buy_box": buy_box,
-            "data_source": data.get("data_source", "live"),
-            "last_synced_at": datetime.now(timezone.utc).isoformat(),
-        }
+"""Shared product fetch, persist, and response building."""
+import json
+import uuid
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from sqlalchemy.orm import Session
+
+from app.models.product import Product, PriceHistory
+from app.services.amazon.product_scraper import scrape_amazon_product
+from app.services.amazon.sales_estimator import estimate_monthly_sales, calculate_opportunity_score
+from app.services.analytics.tracking_service import check_alerts
+from app.services.analytics.buy_box_rotation import estimate_buy_box_rotation
+from app.services.analytics.buy_box_history import (
+    record_buy_box_snapshot,
+    get_buy_box_snapshots,
+    rotation_from_snapshots,
+    build_buy_box_timeline,
+    build_historical_charts_payload,
+)
+
+
+def _load_stored_offers(product: Product) -> List[dict]:
+    raw = getattr(product, "other_sellers_json", None)
+    if not raw:
+        return []
+    try:
+        data = json.loads(raw)
+        return data if isinstance(data, list) else []
+    except (json.JSONDecodeError, TypeError):
+        return []
+
+
+def build_all_competitors(data: dict) -> List[dict]:
+    """Merge buy box winner + other sellers into one sorted competitor list with prices."""
+    bb_price = float(data["buy_box_price"]) if data.get("buy_box_price") else None
+    winner = (data.get("buy_box_winner") or "").strip()
+    has_bb = data.get("has_buy_box", True)
+    rows: List[dict] = []
+    seen: set = set()
+
+    def add_row(
+        seller: str,
+        price,
+        is_fba,
+        is_prime,
+        is_winner: bool,
+        rating=None,
+    ):
+        if not seller:
+            return
+        key = seller.lower()
+        if key in seen:
+            return
+        seen.add(key)
+        p = float(price) if price is not None else None
+        delta = round(p - bb_price, 2) if bb_price is not None and p is not None else None
+        rows.append(
+            {
+                "seller": seller,
+                "price": p,
+                "is_fba": is_fba,
+                "is_prime": bool(is_prime),
+                "is_buy_box_winner": is_winner,
+                "fulfillment": "FBA" if is_fba is True else ("FBM" if is_fba is False else "—"),
+                "price_vs_buy_box": delta,
+                "rating": rating,
+            }
+        )
+
+    if winner and has_bb:
+        add_row(
+            winner,
+            bb_price,
+            data.get("buy_box_is_fba"),
+            data.get("buy_box_is_prime", data.get("is_prime")),
+            True,
+            "98%" if data.get("is_amazon_sold") else "95%",
+        )
+
+    for offer in data.get("other_sellers") or []:
+        add_row(
+            (offer.get("name") or "").strip(),
+            offer.get("price"),
+            offer.get("is_fba"),
+            offer.get("is_prime"),
+            False,
+            offer.get("rating"),
+        )
+
+    rows.sort(key=lambda r: (not r["is_buy_box_winner"], r["price"] if r["price"] is not None else 1e9))
+    return rows
+
+
+def _buy_box_data_from_product(product: Product) -> dict:
+    has_bb = product.has_buy_box if product.has_buy_box is not None else True
+    is_fba = product.buy_box_is_fba
+    seller_count = product.seller_count or 1
+    other_sellers = _load_stored_offers(product)
+    fba_sellers = 0
+    fbm_sellers = 0
+    if is_fba is True:
+        fba_sellers = max(1, seller_count - 1) if seller_count > 1 else 1
+        fbm_sellers = max(0, seller_count - fba_sellers)
+    elif is_fba is False:
+        fbm_sellers = max(1, seller_count)
+        fba_sellers = max(0, seller_count - fbm_sellers)
+    elif other_sellers:
+        fba_sellers = sum(1 for o in other_sellers if o.get("is_fba") is True)
+        fbm_sellers = sum(1 for o in other_sellers if o.get("is_fba") is False)
+    return {
+        "buy_box_winner": product.buy_box_winner,
+        "buy_box_price": float(product.buy_box_price) if product.buy_box_price else None,
+        "buy_box_is_fba": is_fba,
+        "buy_box_is_prime": product.is_prime,
+        "is_amazon_sold": product.is_amazon_sold or False,
+        "seller_count": seller_count,
+        "fba_seller_count": fba_sellers,
+        "fbm_seller_count": fbm_sellers,
+        "has_buy_box": has_bb,
+        "other_sellers": other_sellers,
+        "offers_source": getattr(product, "offers_source", None) or product.last_data_source,
+    }
+
+
+def build_buy_box_analysis(
+    data: dict,
+    price: float,
+    rating: float,
+    reviews: int,
+    rotation: Optional[dict] = None,
+    history_timeline: Optional[list] = None,
+) -> dict:
+    """Build complete buy box analysis from scraped + calculated data."""
+    buy_box_winner = data.get("buy_box_winner") or "Unknown"
+    buy_box_price = data.get("buy_box_price") or price
+    is_fba = data.get("buy_box_is_fba")
+    is_prime = data.get("buy_box_is_prime", True)
+    is_amazon = data.get("is_amazon_sold", False)
+    seller_count = data.get("seller_count", 1)
+    has_buy_box = data.get("has_buy_box", True)
+    fba_seller_count = data.get("fba_seller_count")
+    fbm_seller_count = data.get("fbm_seller_count")
+    if fba_seller_count is None and fbm_seller_count is None:
+        if is_fba is True:
+            fba_seller_count = max(1, seller_count)
+            fbm_seller_count = max(0, seller_count - fba_seller_count)
+        elif is_fba is False:
+            fbm_seller_count = max(1, seller_count)
+            fba_seller_count = max(0, seller_count - fbm_seller_count)
+        else:
+            fba_seller_count = None
+            fbm_seller_count = None
+
+    score = 0
+    factors = []
+
+    if price and buy_box_price:
+        price_diff_pct = abs(price - buy_box_price) / buy_box_price * 100
+        if price_diff_pct <= 2:
+            score += 25
+            factors.append({"factor": "Price", "status": "Competitive ✓", "color": "#10B981",
+                           "detail": f"${price} is within 2% of buy box price (${buy_box_price})"})
+        elif price_diff_pct <= 10:
+            score += 15
+            factors.append({"factor": "Price", "status": "Close", "color": "#F59E0B",
+                           "detail": f"${price} is {price_diff_pct:.1f}% from buy box price (${buy_box_price})"})
+        else:
+            score += 5
+            factors.append({"factor": "Price", "status": "Too High", "color": "#EF4444",
+                           "detail": f"${price} is {price_diff_pct:.1f}% above buy box price — lower price to compete"})
+    else:
+        score += 15
+        factors.append({"factor": "Price", "status": "Unknown", "color": "#9CA3AF", "detail": "Could not determine price gap"})
+
+    if is_fba is True:
+        score += 30
+        factors.append({"factor": "Fulfillment", "status": "FBA ✓", "color": "#10B981",
+                       "detail": "FBA strongly favored — Amazon prefers its own fulfillment"})
+    elif is_fba is False:
+        score += 5
+        factors.append({"factor": "Fulfillment", "status": "FBM ✗", "color": "#EF4444",
+                       "detail": "FBM sellers rarely win buy box — switch to FBA"})
+    else:
+        score += 10
+        factors.append({"factor": "Fulfillment", "status": "Unknown", "color": "#9CA3AF",
+                       "detail": "Fulfillment type unclear — refresh product data"})
+
+    if is_prime:
+        score += 20
+        factors.append({"factor": "Prime Badge", "status": "Eligible ✓", "color": "#10B981",
+                       "detail": "Prime eligible — required for consistent buy box wins"})
+    else:
+        factors.append({"factor": "Prime Badge", "status": "Not Eligible ✗", "color": "#EF4444",
+                       "detail": "No Prime = very low chance of winning buy box"})
+
+    if rating and rating >= 4.5:
+        score += 15
+        factors.append({"factor": "Seller Rating", "status": "Excellent ✓", "color": "#10B981",
+                       "detail": f"{rating}★ — Amazon heavily favors high-rated sellers"})
+    elif rating and rating >= 4.0:
+        score += 10
+        factors.append({"factor": "Seller Rating", "status": "Good", "color": "#F59E0B",
+                       "detail": f"{rating}★ — acceptable but not ideal for buy box"})
+    else:
+        score += 3
+        factors.append({"factor": "Seller Rating", "status": "Needs Work ✗", "color": "#EF4444",
+                       "detail": f"{rating or 'Unknown'}★ — low rating significantly hurts buy box eligibility"})
+
+    if seller_count <= 2:
+        score += 10
+        factors.append({"factor": "Competition", "status": f"Low ({seller_count} sellers)", "color": "#10B981",
+                       "detail": "Few sellers = easier to win and keep buy box"})
+    elif seller_count <= 5:
+        score += 6
+        factors.append({"factor": "Competition", "status": f"Medium ({seller_count} sellers)", "color": "#F59E0B",
+                       "detail": f"{seller_count} competing sellers — maintain competitive price"})
+    else:
+        score += 2
+        factors.append({"factor": "Competition", "status": f"High ({seller_count}+ sellers)", "color": "#EF4444",
+                       "detail": f"{seller_count}+ sellers competing — very hard to win consistently"})
+
+    score = min(score, 100)
+
+    if score >= 75:
+        verdict, verdict_color = "Strong Buy Box Candidate", "#10B981"
+    elif score >= 50:
+        verdict, verdict_color = "Moderate Chance", "#F59E0B"
+    elif score >= 25:
+        verdict, verdict_color = "Low Chance", "#FB923C"
+    else:
+        verdict, verdict_color = "Unlikely to Win", "#EF4444"
+
+    owner_badge = "🟡 3rd Party"
+    owner_color = "#F59E0B"
+    if is_amazon:
+        owner_badge = "🔵 Amazon"
+        owner_color = "#3B82F6"
+    elif is_fba is True:
+        owner_badge = "🟢 FBA Seller"
+        owner_color = "#10B981"
+    elif is_fba is False:
+        owner_badge = "🟠 FBM Seller"
+        owner_color = "#F59E0B"
+
+    rotation_data = {
+        **data,
+        "buy_box_winner": buy_box_winner,
+        "buy_box_price": buy_box_price,
+        "buy_box_is_fba": is_fba,
+        "seller_count": seller_count,
+        "has_buy_box": has_buy_box,
+        "price": price,
+    }
+    if rotation is None:
+        rotation = estimate_buy_box_rotation(rotation_data) if has_buy_box else {"sellers": [], "eligible_fba": 0, "eligible_fbm": 0}
+        rotation["source"] = "estimated"
+
+    all_competitors = build_all_competitors(rotation_data)
+    offers_source = data.get("offers_source") or "unknown"
+
+    return {
+        "score": score,
+        "verdict": verdict,
+        "verdict_color": verdict_color,
+        "factors": factors,
+        "has_buy_box": has_buy_box,
+        "current_winner": buy_box_winner if has_buy_box else None,
+        "current_winner_badge": owner_badge if has_buy_box else "No Buy Box",
+        "current_winner_color": owner_color,
+        "buy_box_price": buy_box_price if has_buy_box else None,
+        "seller_count": seller_count,
+        "fba_seller_count": fba_seller_count,
+        "fbm_seller_count": fbm_seller_count,
+        "is_amazon_sold": is_amazon,
+        "is_fba": is_fba,
+        "is_prime": is_prime,
+        "tips": [
+            "Price within 1-2% of the current buy box price",
+            "Always use FBA — Amazon strongly favors it",
+            "Maintain seller feedback score above 95%",
+            "Keep order defect rate below 1%",
+            "Respond to customer messages within 24 hours",
+        ],
+        "other_sellers": data.get("other_sellers", []),
+        "all_competitors": all_competitors,
+        "offers_source": offers_source,
+        "rotation": rotation,
+        "history_timeline": history_timeline or [],
+    }
+
+
+def persist_scrape(db: Session, product: Optional[Product], asin: str, data: dict) -> Product:
+    if not product:
+        product = Product(
+            id=str(uuid.uuid4()),
+            asin=asin,
+            title=data["title"],
+            brand=data["brand"],
+            upc=data.get("upc"),
+            category=data["category"],
+            image_url=data["image_url"],
+            amazon_url=data["amazon_url"],
+            is_prime=data["is_prime"],
+        )
+        db.add(product)
+        db.flush()
+    else:
+        product.title = data["title"]
+        product.brand = data["brand"]
+        product.upc = data.get("upc") or product.upc
+        product.category = data.get("category") or product.category
+        product.image_url = data.get("image_url") or product.image_url
+        product.is_prime = data.get("is_prime", product.is_prime)
+
+    product.seller_count = data.get("seller_count", 1)
+    product.buy_box_winner = data.get("buy_box_winner")
+    product.buy_box_price = data.get("buy_box_price")
+    product.buy_box_is_fba = data.get("buy_box_is_fba") if "buy_box_is_fba" in data else product.buy_box_is_fba
+    product.has_buy_box = data.get("has_buy_box", True)
+    product.is_amazon_sold = data.get("is_amazon_sold", False)
+    if data.get("package_weight_lbs") is not None:
+        product.package_weight_lbs = data.get("package_weight_lbs")
+    if data.get("other_sellers") is not None:
+        product.other_sellers_json = json.dumps(data["other_sellers"][:30])
+    if data.get("offers_source"):
+        product.offers_source = data.get("offers_source")
+    product.last_data_source = data.get("data_source", "live")
+    product.last_synced_at = datetime.now(timezone.utc)
+
+    history = PriceHistory(
+        id=str(uuid.uuid4()),
+        product_id=str(product.id),
+        price=data["price"],
+        bsr=data["bsr"],
+        rating=data["rating"],
+        review_count=data["review_count"],
+        in_stock=data["in_stock"],
+    )
+    db.add(history)
+    record_buy_box_snapshot(db, str(product.id), data)
+    db.commit()
+    db.refresh(product)
+
+    if data.get("price"):
+        check_alerts(db, asin, float(data["price"]), data.get("bsr"))
+
+    return product
+
+
+def build_response(db: Session, product: Product, data_source: str = "cached") -> dict:
+    history = (
+        db.query(PriceHistory)
+        .filter(PriceHistory.product_id == product.id)
+        .order_by(PriceHistory.recorded_at.desc())
+        .limit(180)
+        .all()
+    )
+    latest = history[0] if history else None
+    sales_data = estimate_monthly_sales(latest.bsr if latest else 0, product.category or "")
+
+    seller_count = product.seller_count or 1
+    opportunity_score = None
+    if latest and sales_data["monthly_units"]:
+        opportunity_score = calculate_opportunity_score(
+            bsr=latest.bsr or 0,
+            review_count=latest.review_count or 0,
+            monthly_sales=sales_data["monthly_units"],
+            seller_count=seller_count,
+        )
+
+    price = float(latest.price) if latest and latest.price else None
+    rating = float(latest.rating) if latest and latest.rating else None
+    reviews = latest.review_count if latest else 0
+
+    bb_data = _buy_box_data_from_product(product)
+    snapshots = get_buy_box_snapshots(db, str(product.id), days=90)
+    rotation = rotation_from_snapshots(snapshots, range_days=30, fallback_data={**bb_data, "price": price})
+    history_timeline = build_buy_box_timeline(snapshots, range_days=30)
+    price_history_rows = [
+        {
+            "price": float(h.price) if h.price else None,
+            "bsr": h.bsr,
+            "rating": float(h.rating) if h.rating else None,
+            "review_count": h.review_count,
+            "recorded_at": h.recorded_at.isoformat(),
+        }
+        for h in reversed(history)
+    ]
+    historical_charts = build_historical_charts_payload(
+        snapshots,
+        price_history_rows,
+        category=product.category or "default",
+        range_days=365,
+        weight_lbs=float(product.package_weight_lbs) if product.package_weight_lbs else 1.0,
+    )
+
+    buy_box = build_buy_box_analysis(
+        bb_data,
+        price=price or 25,
+        rating=rating or 4.0,
+        reviews=reviews or 100,
+        rotation=rotation,
+        history_timeline=history_timeline,
+    )
+
+    source = product.last_data_source or data_source
+    last_synced = product.last_synced_at.isoformat() if product.last_synced_at else None
+
+    return {
+        "asin": product.asin,
+        "title": product.title,
+        "brand": product.brand,
+        "upc": product.upc,
+        "category": product.category,
+        "image_url": product.image_url,
+        "amazon_url": product.amazon_url,
+        "is_prime": product.is_prime,
+        "current_price": price,
+        "current_bsr": latest.bsr if latest else None,
+        "current_rating": rating,
+        "current_review_count": latest.review_count if latest else None,
+        "in_stock": latest.in_stock if latest else None,
+        "sales_estimate_monthly": sales_data["monthly_units"],
+        "revenue_estimate_monthly": round(sales_data["monthly_units"] * price, 2) if sales_data["monthly_units"] and price else None,
+        "opportunity_score": opportunity_score,
+        "price_history": price_history_rows,
+        "buy_box": buy_box,
+        "buy_box_history": {
+            "snapshot_count": len(snapshots),
+            "source": rotation.get("source", "estimated"),
+            "timeline": history_timeline,
+            "snapshots": historical_charts.get("buy_box_price_series", []),
+            "charts": historical_charts,
+        },
+        "historical_charts": historical_charts,
+        "package_weight_lbs": float(product.package_weight_lbs) if product.package_weight_lbs else None,
+        "data_source": source,
+        "last_synced_at": last_synced,
+    }
+
+
+def fetch_and_sync_product(db: Session, asin: str, force: bool = False) -> dict:
+    product = db.query(Product).filter(Product.asin == asin).first()
+    needs_refresh = force
+
+    if not needs_refresh and product and product.last_synced_at:
+        last_synced = product.last_synced_at
+        if last_synced.tzinfo is None:
+            last_synced = last_synced.replace(tzinfo=timezone.utc)
+        age_hours = (datetime.now(timezone.utc) - last_synced).total_seconds() / 3600
+        needs_refresh = age_hours > 6
+
+    if not needs_refresh and product:
+        return build_response(db, product, "cached")
+
+    data = scrape_amazon_product(asin)
+    if not data:
+        if product:
+            resp = build_response(db, product, "cached")
+            resp["data_source"] = product.last_data_source or "cached"
+            return resp
+        return None
+
+    try:
+        product = persist_scrape(db, product, asin, data)
+        return build_response(db, product, data.get("data_source", "live"))
+    except Exception as e:
+        db.rollback()
+        print(f"[product_service] DB error: {e}")
+        sales_data = estimate_monthly_sales(data.get("bsr") or 0, data.get("category") or "")
+        opp = calculate_opportunity_score(
+            bsr=data.get("bsr") or 0,
+            review_count=data.get("review_count") or 0,
+            monthly_sales=sales_data["monthly_units"],
+            seller_count=data.get("seller_count", 1),
+        ) if sales_data["monthly_units"] else None
+        buy_box = build_buy_box_analysis(
+            data,
+            price=data.get("price") or 25,
+            rating=data.get("rating") or 4.0,
+            reviews=data.get("review_count") or 100,
+        )
+        return {
+            "asin": asin,
+            "title": data["title"],
+            "brand": data["brand"],
+            "category": data["category"],
+            "image_url": data["image_url"],
+            "amazon_url": data["amazon_url"],
+            "is_prime": data.get("is_prime"),
+            "current_price": data["price"],
+            "current_bsr": data["bsr"],
+            "current_rating": data["rating"],
+            "current_review_count": data["review_count"],
+            "in_stock": data["in_stock"],
+            "sales_estimate_monthly": sales_data["monthly_units"],
+            "revenue_estimate_monthly": round(sales_data["monthly_units"] * (data["price"] or 0), 2) if sales_data["monthly_units"] and data["price"] else None,
+            "opportunity_score": opp,
+            "price_history": [],
+            "buy_box": buy_box,
+            "data_source": data.get("data_source", "live"),
+            "last_synced_at": datetime.now(timezone.utc).isoformat(),
+        }

app/services/scheduler.py

@@ -1,42 +1,42 @@
-"""Background refresh of tracked products."""
-import threading
-import time
-from app.database import SessionLocal
-from app.models.product import TrackedProduct, Product
-from app.services.product_service import fetch_and_sync_product
-
-
-def refresh_all_tracked():
-    db = SessionLocal()
-    try:
-        asins = set()
-        try:
-            tracked = db.query(TrackedProduct).all()
-        except Exception as e:
-            print(f"[scheduler] DB query failed: {e}")
-            return
-        for row in tracked:
-            product = db.query(Product).filter(Product.id == row.product_id).first()
-            if product:
-                asins.add(product.asin)
-        for asin in asins:
-            try:
-                fetch_and_sync_product(db, asin, force=True)
-                print(f"[scheduler] Refreshed {asin}")
-            except Exception as e:
-                print(f"[scheduler] Failed {asin}: {e}")
-    finally:
-        db.close()
-
-
-def _loop(interval_hours: float = 6.0):
-    while True:
-        time.sleep(interval_hours * 3600)
-        print("[scheduler] Running tracked product refresh...")
-        refresh_all_tracked()
-
-
-def start_background_scheduler(interval_hours: float = 6.0):
-    thread = threading.Thread(target=_loop, args=(interval_hours,), daemon=True)
-    thread.start()
-    print(f"[scheduler] Background refresh every {interval_hours}h started")
+"""Background refresh of tracked products."""
+import threading
+import time
+from app.database import SessionLocal
+from app.models.product import TrackedProduct, Product
+from app.services.product_service import fetch_and_sync_product
+
+
+def refresh_all_tracked():
+    db = SessionLocal()
+    try:
+        asins = set()
+        try:
+            tracked = db.query(TrackedProduct).all()
+        except Exception as e:
+            print(f"[scheduler] DB query failed: {e}")
+            return
+        for row in tracked:
+            product = db.query(Product).filter(Product.id == row.product_id).first()
+            if product:
+                asins.add(product.asin)
+        for asin in asins:
+            try:
+                fetch_and_sync_product(db, asin, force=True)
+                print(f"[scheduler] Refreshed {asin}")
+            except Exception as e:
+                print(f"[scheduler] Failed {asin}: {e}")
+    finally:
+        db.close()
+
+
+def _loop(interval_hours: float = 6.0):
+    while True:
+        time.sleep(interval_hours * 3600)
+        print("[scheduler] Running tracked product refresh...")
+        refresh_all_tracked()
+
+
+def start_background_scheduler(interval_hours: float = 6.0):
+    thread = threading.Thread(target=_loop, args=(interval_hours,), daemon=True)
+    thread.start()
+    print(f"[scheduler] Background refresh every {interval_hours}h started")

app/services/supplier_service.py

@@ -1,153 +1,153 @@
-"""Check wholesale marketplaces for listings matching a product title."""
-import re
-import urllib.parse
-from typing import Optional
-
-import requests
-from bs4 import BeautifulSoup
-
-from app.config import settings
-
-SUPPLIERS = [
-    {"id": "ebay", "name": "eBay", "accent": "#E53238"},
-    {"id": "alibaba", "name": "Alibaba", "accent": "#FF6A00"},
-    {"id": "walmart", "name": "Walmart", "accent": "#0071CE"},
-    {"id": "bigw", "name": "Big W", "accent": "#D32323"},
-]
-
-STOP_WORDS = {
-    "the", "a", "an", "and", "or", "for", "with", "in", "on", "of", "to", "by",
-    "pack", "set", "new", "free", "shipping", "size", "color", "amazon", "official",
-}
-
-
-def _fetch_html(url: str, timeout: int = 20) -> Optional[str]:
-    if settings.scraper_api_key:
-        try:
-            resp = requests.get(
-                "https://api.scraperapi.com",
-                params={"api_key": settings.scraper_api_key, "url": url},
-                timeout=timeout,
-            )
-            if resp.status_code == 200 and len(resp.text) > 400:
-                return resp.text
-        except Exception as e:
-            print(f"[suppliers] ScraperAPI error: {e}")
-
-    try:
-        resp = requests.get(
-            url,
-            headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/122.0.0.0 Safari/537.36"},
-            timeout=10,
-        )
-        if resp.status_code == 200 and len(resp.text) > 400:
-            return resp.text
-    except Exception as e:
-        print(f"[suppliers] Fetch error: {e}")
-    return None
-
-
-def build_search_query(title: str, brand: str = "") -> str:
-    from app.security.input_guard import strip_for_regex, MAX_QUERY_LEN
-    raw = strip_for_regex(f"{brand} {title or ''}", MAX_QUERY_LEN)
-    words = re.findall(r"[A-Za-z0-9]+", raw)
-    picked: list[str] = []
-    seen: set[str] = set()
-    for w in words:
-        low = w.lower()
-        if low in STOP_WORDS or len(w) < 2 or low in seen:
-            continue
-        seen.add(low)
-        picked.append(w)
-        if len(picked) >= 5:
-            break
-    return " ".join(picked) if picked else (brand or title or "")[:60]
-
-
-def _check_ebay(query: str) -> Optional[dict]:
-    url = f"https://www.ebay.com/sch/i.html?_nkw={urllib.parse.quote(query)}"
-    html = _fetch_html(url)
-    if not html:
-        return None
-    soup = BeautifulSoup(html, "html.parser")
-    items = [el for el in soup.select("li.s-item") if el.select_one(".s-item__title")]
-    if len(items) >= 1:
-        return {"id": "ebay", "name": "eBay", "url": url, "accent": "#E53238", "count": len(items)}
-    if "results for" in html.lower() and "0 results" not in html.lower():
-        return {"id": "ebay", "name": "eBay", "url": url, "accent": "#E53238", "count": 1}
-    return None
-
-
-def _check_alibaba(query: str) -> Optional[dict]:
-    url = f"https://www.alibaba.com/trade/search?SearchText={urllib.parse.quote(query)}"
-    html = _fetch_html(url)
-    if not html:
-        return None
-    low = html.lower()
-    if any(x in low for x in ("organic-list-offer", "search-card", "product-item", "gallery-offer")):
-        return {"id": "alibaba", "name": "Alibaba", "url": url, "accent": "#FF6A00", "count": 1}
-    if "no matching results" in low or "0 product" in low:
-        return None
-    return None
-
-
-def _check_walmart(query: str) -> Optional[dict]:
-    url = f"https://www.walmart.com/search?q={urllib.parse.quote(query)}"
-    html = _fetch_html(url)
-    if not html:
-        return None
-    soup = BeautifulSoup(html, "html.parser")
-    if soup.select('[data-testid="list-view"], [data-item-id], div[data-automation-id="product-title"]'):
-        return {"id": "walmart", "name": "Walmart", "url": url, "accent": "#0071CE", "count": 1}
-    low = html.lower()
-    if "results for" in low and "no results" not in low:
-        return {"id": "walmart", "name": "Walmart", "url": url, "accent": "#0071CE", "count": 1}
-    return None
-
-
-def _check_bigw(query: str) -> Optional[dict]:
-    url = f"https://www.bigw.com.au/search?q={urllib.parse.quote(query)}"
-    html = _fetch_html(url)
-    if not html:
-        return None
-    low = html.lower()
-    if any(x in low for x in ("product-tile", "search-results", "article[data-testid", "product-card")):
-        return {"id": "bigw", "name": "Big W", "url": url, "accent": "#D32323", "count": 1}
-    if "no results" in low or "0 results" in low:
-        return None
-    return None
-
-
-CHECKERS = {
-    "ebay": _check_ebay,
-    "alibaba": _check_alibaba,
-    "walmart": _check_walmart,
-    "bigw": _check_bigw,
-}
-
-
-def find_suppliers(title: str, brand: str = "", asin: str = "") -> dict:
-    query = build_search_query(title, brand)
-    found = []
-    for sid, checker in CHECKERS.items():
-        try:
-            hit = checker(query)
-            if hit:
-                found.append(hit)
-        except Exception as e:
-            print(f"[suppliers] {sid} check failed: {e}")
-
-    if not found and settings.allow_mock_data and title:
-        mock_ids = ["ebay", "alibaba"] if len(query.split()) >= 2 else ["ebay"]
-        for sid in mock_ids:
-            meta = next(s for s in SUPPLIERS if s["id"] == sid)
-            q = urllib.parse.quote(query)
-            urls = {
-                "ebay": f"https://www.ebay.com/sch/i.html?_nkw={q}",
-                "alibaba": f"https://www.alibaba.com/trade/search?SearchText={q}",
-                "walmart": f"https://www.walmart.com/search?q={q}",
-                "bigw": f"https://www.bigw.com.au/search?q={q}",
-            }
-            found.append({**meta, "url": urls[sid], "count": 1, "estimated": True})
-
-    return {"query": query, "asin": asin, "suppliers": found}
+"""Check wholesale marketplaces for listings matching a product title."""
+import re
+import urllib.parse
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup
+
+from app.config import settings
+
+SUPPLIERS = [
+    {"id": "ebay", "name": "eBay", "accent": "#E53238"},
+    {"id": "alibaba", "name": "Alibaba", "accent": "#FF6A00"},
+    {"id": "walmart", "name": "Walmart", "accent": "#0071CE"},
+    {"id": "bigw", "name": "Big W", "accent": "#D32323"},
+]
+
+STOP_WORDS = {
+    "the", "a", "an", "and", "or", "for", "with", "in", "on", "of", "to", "by",
+    "pack", "set", "new", "free", "shipping", "size", "color", "amazon", "official",
+}
+
+
+def _fetch_html(url: str, timeout: int = 20) -> Optional[str]:
+    if settings.scraper_api_key:
+        try:
+            resp = requests.get(
+                "https://api.scraperapi.com",
+                params={"api_key": settings.scraper_api_key, "url": url},
+                timeout=timeout,
+            )
+            if resp.status_code == 200 and len(resp.text) > 400:
+                return resp.text
+        except Exception as e:
+            print(f"[suppliers] ScraperAPI error: {e}")
+
+    try:
+        resp = requests.get(
+            url,
+            headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/122.0.0.0 Safari/537.36"},
+            timeout=10,
+        )
+        if resp.status_code == 200 and len(resp.text) > 400:
+            return resp.text
+    except Exception as e:
+        print(f"[suppliers] Fetch error: {e}")
+    return None
+
+
+def build_search_query(title: str, brand: str = "") -> str:
+    from app.security.input_guard import strip_for_regex, MAX_QUERY_LEN
+    raw = strip_for_regex(f"{brand} {title or ''}", MAX_QUERY_LEN)
+    words = re.findall(r"[A-Za-z0-9]+", raw)
+    picked: list[str] = []
+    seen: set[str] = set()
+    for w in words:
+        low = w.lower()
+        if low in STOP_WORDS or len(w) < 2 or low in seen:
+            continue
+        seen.add(low)
+        picked.append(w)
+        if len(picked) >= 5:
+            break
+    return " ".join(picked) if picked else (brand or title or "")[:60]
+
+
+def _check_ebay(query: str) -> Optional[dict]:
+    url = f"https://www.ebay.com/sch/i.html?_nkw={urllib.parse.quote(query)}"
+    html = _fetch_html(url)
+    if not html:
+        return None
+    soup = BeautifulSoup(html, "html.parser")
+    items = [el for el in soup.select("li.s-item") if el.select_one(".s-item__title")]
+    if len(items) >= 1:
+        return {"id": "ebay", "name": "eBay", "url": url, "accent": "#E53238", "count": len(items)}
+    if "results for" in html.lower() and "0 results" not in html.lower():
+        return {"id": "ebay", "name": "eBay", "url": url, "accent": "#E53238", "count": 1}
+    return None
+
+
+def _check_alibaba(query: str) -> Optional[dict]:
+    url = f"https://www.alibaba.com/trade/search?SearchText={urllib.parse.quote(query)}"
+    html = _fetch_html(url)
+    if not html:
+        return None
+    low = html.lower()
+    if any(x in low for x in ("organic-list-offer", "search-card", "product-item", "gallery-offer")):
+        return {"id": "alibaba", "name": "Alibaba", "url": url, "accent": "#FF6A00", "count": 1}
+    if "no matching results" in low or "0 product" in low:
+        return None
+    return None
+
+
+def _check_walmart(query: str) -> Optional[dict]:
+    url = f"https://www.walmart.com/search?q={urllib.parse.quote(query)}"
+    html = _fetch_html(url)
+    if not html:
+        return None
+    soup = BeautifulSoup(html, "html.parser")
+    if soup.select('[data-testid="list-view"], [data-item-id], div[data-automation-id="product-title"]'):
+        return {"id": "walmart", "name": "Walmart", "url": url, "accent": "#0071CE", "count": 1}
+    low = html.lower()
+    if "results for" in low and "no results" not in low:
+        return {"id": "walmart", "name": "Walmart", "url": url, "accent": "#0071CE", "count": 1}
+    return None
+
+
+def _check_bigw(query: str) -> Optional[dict]:
+    url = f"https://www.bigw.com.au/search?q={urllib.parse.quote(query)}"
+    html = _fetch_html(url)
+    if not html:
+        return None
+    low = html.lower()
+    if any(x in low for x in ("product-tile", "search-results", "article[data-testid", "product-card")):
+        return {"id": "bigw", "name": "Big W", "url": url, "accent": "#D32323", "count": 1}
+    if "no results" in low or "0 results" in low:
+        return None
+    return None
+
+
+CHECKERS = {
+    "ebay": _check_ebay,
+    "alibaba": _check_alibaba,
+    "walmart": _check_walmart,
+    "bigw": _check_bigw,
+}
+
+
+def find_suppliers(title: str, brand: str = "", asin: str = "") -> dict:
+    query = build_search_query(title, brand)
+    found = []
+    for sid, checker in CHECKERS.items():
+        try:
+            hit = checker(query)
+            if hit:
+                found.append(hit)
+        except Exception as e:
+            print(f"[suppliers] {sid} check failed: {e}")
+
+    if not found and settings.allow_mock_data and title:
+        mock_ids = ["ebay", "alibaba"] if len(query.split()) >= 2 else ["ebay"]
+        for sid in mock_ids:
+            meta = next(s for s in SUPPLIERS if s["id"] == sid)
+            q = urllib.parse.quote(query)
+            urls = {
+                "ebay": f"https://www.ebay.com/sch/i.html?_nkw={q}",
+                "alibaba": f"https://www.alibaba.com/trade/search?SearchText={q}",
+                "walmart": f"https://www.walmart.com/search?q={q}",
+                "bigw": f"https://www.bigw.com.au/search?q={q}",
+            }
+            found.append({**meta, "url": urls[sid], "count": 1, "estimated": True})
+
+    return {"query": query, "asin": asin, "suppliers": found}

app/utils/validators.py

@@ -1,11 +1,11 @@
-"""Input validation: SSTI, SQL/NoSQL injection probes, ReDoS-safe string handling."""
-import re
-from fastapi import HTTPException
-
-from app.security.input_guard import normalize_asin_safe
-
-ASIN_PATTERN = re.compile(r"^[A-Z0-9]{10}$")
-
-
-def normalize_asin(asin: str) -> str:
-    return normalize_asin_safe(asin)
+"""Input validation: SSTI, SQL/NoSQL injection probes, ReDoS-safe string handling."""
+import re
+from fastapi import HTTPException
+
+from app.security.input_guard import normalize_asin_safe
+
+ASIN_PATTERN = re.compile(r"^[A-Z0-9]{10}$")
+
+
+def normalize_asin(asin: str) -> str:
+    return normalize_asin_safe(asin)

requirements.txt

@@ -1,20 +1,20 @@
-fastapi>=0.109.0
-uvicorn[standard]>=0.27.0
-sqlalchemy>=2.0.25
-pydantic[email]>=2.5.0
-pydantic-settings>=2.0.0
-email-validator>=2.0.0
-python-multipart
-python-dotenv
-bcrypt>=4.0.0
-python-jose[cryptography]
-requests
-beautifulsoup4
-lxml
-psycopg2-binary
-google-generativeai>=0.8.0
-openai>=1.0.0
-anthropic>=0.25.0
-httpx
-numpy>=1.26.0
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+sqlalchemy>=2.0.25
+pydantic[email]>=2.5.0
+pydantic-settings>=2.0.0
+email-validator>=2.0.0
+python-multipart
+python-dotenv
+bcrypt>=4.0.0
+python-jose[cryptography]
+requests
+beautifulsoup4
+lxml
+psycopg2-binary
+google-generativeai>=0.8.0
+openai>=1.0.0
+anthropic>=0.25.0
+httpx
+numpy>=1.26.0
 scikit-learn>=1.4.0