proposal-system/lambdas/library-ingest/app.py

"""Proposal System - Library Ingest Lambda.

Processes approved/sent proposals into the Bedrock Knowledge Base library.
Formats proposal data as structured markdown and uploads to the library bucket,
then triggers a KB sync.
"""

import json
import os
from datetime import datetime

import boto3
import httpx

LIBRARY_BUCKET = os.environ.get("LIBRARY_BUCKET", "")
KNOWLEDGE_BASE_ID = os.environ.get("KNOWLEDGE_BASE_ID", "")
DATA_SOURCE_ID = os.environ.get("DATA_SOURCE_ID", "")
API_BASE_URL = os.environ.get("API_BASE_URL", "")
INTERNAL_API_KEY_SECRET_ARN = os.environ.get("INTERNAL_API_KEY_SECRET_ARN", "")

s3 = boto3.client("s3")
bedrock_agent = boto3.client("bedrock-agent")
secrets_client = boto3.client("secretsmanager")

_cached_api_key: str | None = None


def _get_api_key() -> str:
    global _cached_api_key
    if _cached_api_key is None:
        if INTERNAL_API_KEY_SECRET_ARN:
            resp = secrets_client.get_secret_value(SecretId=INTERNAL_API_KEY_SECRET_ARN)
            _cached_api_key = resp["SecretString"]
        else:
            _cached_api_key = ""
    return _cached_api_key


def handler(event, context):
    for record in event.get("Records", []):
        body = json.loads(record["body"])
        payload = body.get("payload", body)
        proposal_id = payload["proposalId"]
        process_ingestion(proposal_id)
    return {"statusCode": 200}


def process_ingestion(proposal_id: str):
    proposal = fetch_proposal(proposal_id)
    if not proposal:
        print(f"Proposal {proposal_id} not found")
        return

    line_items = fetch_line_items(proposal_id)

    document = format_proposal_document(proposal, line_items)

    s3_key = upload_to_library(proposal, document)

    if s3_key:
        trigger_kb_sync()


def fetch_proposal(proposal_id: str) -> dict | None:
    try:
        resp = httpx.get(
            f"{API_BASE_URL}/api/proposals/{proposal_id}",
            headers=_api_headers(),
            timeout=10,
        )
        if resp.status_code == 200:
            return resp.json()
    except Exception as e:
        print(f"Error fetching proposal: {e}")
    return None


def fetch_line_items(proposal_id: str) -> list[dict]:
    try:
        resp = httpx.get(
            f"{API_BASE_URL}/api/proposals/{proposal_id}/line-items",
            headers=_api_headers(),
            timeout=10,
        )
        if resp.status_code == 200:
            return resp.json()
    except Exception as e:
        print(f"Error fetching line items: {e}")
    return []


def format_proposal_document(proposal: dict, line_items: list[dict]) -> str:
    total = sum(li.get("totalPrice", 0) for li in line_items)
    submitted_at = proposal.get("submittedAt", "")
    if submitted_at:
        try:
            dt = datetime.fromisoformat(submitted_at.replace("Z", "+00:00"))
            submitted_at = dt.strftime("%Y-%m-%d")
        except (ValueError, TypeError):
            pass

    lines = [
        f"# Proposal: {proposal['proposalNumber']}",
        "",
        f"**Customer:** {proposal['customerName']}",
        f"**Address:** {proposal.get('customerAddress', '')}",
        f"**Service Category:** {proposal['serviceCategory']}",
        f"**Priority:** {proposal['priority']}",
        f"**Date:** {submitted_at}",
        f"**Total Bid Amount:** ${total:,.2f}",
        f"**Work Order:** {proposal.get('workOrderNumber', '')}",
        "",
        "## Scope of Work",
        "",
        proposal.get("refinedScope") or proposal.get("scopeOfWork", ""),
        "",
        "## Line Items",
        "",
        "| # | Description | Qty | Unit | Unit Price | Total |",
        "|---|---|---|---|---|---|",
    ]

    for i, li in enumerate(line_items, 1):
        desc = li.get("description", "")
        qty = li.get("quantity", "")
        unit = li.get("unit", "")
        unit_price = li.get("unitPrice")
        total_price = li.get("totalPrice", 0)

        up_str = f"${unit_price:,.2f}" if unit_price else "-"
        tp_str = f"${total_price:,.2f}"

        lines.append(f"| {i} | {desc} | {qty} | {unit} | {up_str} | {tp_str} |")

    lines.extend(
        [
            "",
            f"**Total: ${total:,.2f}**",
        ]
    )

    return "\n".join(lines)


def upload_to_library(proposal: dict, document: str) -> str | None:
    if not LIBRARY_BUCKET:
        print("No library bucket configured")
        return None

    proposal_number = proposal["proposalNumber"]
    category = proposal.get("serviceCategory", "General")
    s3_key = f"proposals/{category.lower()}/{proposal_number}.md"

    try:
        s3.put_object(
            Bucket=LIBRARY_BUCKET,
            Key=s3_key,
            Body=document.encode("utf-8"),
            ContentType="text/markdown",
            Metadata={
                "service-category": category,
                "proposal-number": proposal_number,
                "customer-name": proposal.get("customerName", ""),
                "total-amount": str(proposal.get("totalBidAmount", 0)),
                "date-submitted": proposal.get("submittedAt", ""),
            },
        )
        print(f"Uploaded {s3_key} to library bucket")
        return s3_key
    except Exception as e:
        print(f"Error uploading to library: {e}")
        return None


def trigger_kb_sync():
    if not KNOWLEDGE_BASE_ID or not DATA_SOURCE_ID:
        print("KB or data source ID not configured, skipping sync")
        return

    try:
        response = bedrock_agent.start_ingestion_job(
            knowledgeBaseId=KNOWLEDGE_BASE_ID,
            dataSourceId=DATA_SOURCE_ID,
        )
        job_id = response.get("ingestionJob", {}).get("ingestionJobId", "")
        print(f"Started KB ingestion job: {job_id}")
    except Exception as e:
        print(f"Error triggering KB sync: {e}")


def _api_headers() -> dict:
    headers = {"Content-Type": "application/json"}
    api_key = _get_api_key()
    if api_key:
        headers["X-Internal-Api-Key"] = api_key
    return headers