Implementation Guide: Transcribe on-site walkthrough notes and generate punch list items for review

aws s3 mb s3://client-name-walkthrough-audio --region us-east-1
aws s3api put-bucket-lifecycle-configuration --bucket client-name-walkthrough-audio --lifecycle-configuration '{"Rules":[{"ID":"DeleteRawAudioAfter90Days","Filter":{"Prefix":"raw-audio/"},"Status":"Enabled","Expiration":{"Days":90}},{"ID":"DeleteProcessedAudioAfter180Days","Filter":{"Prefix":"processed/"},"Status":"Enabled","Expiration":{"Days":180}}]}'
aws s3api put-bucket-encryption --bucket client-name-walkthrough-audio --server-side-encryption-configuration '{"Rules":[{"ApplyServerSideEncryptionByDefault":{"SSEAlgorithm":"AES256"}}]}'
aws dynamodb create-table --table-name client-name-punch-items --attribute-definitions AttributeName=walkthrough_id,AttributeType=S AttributeName=item_id,AttributeType=S --key-schema AttributeName=walkthrough_id,KeyType=HASH AttributeName=item_id,KeyType=RANGE --billing-mode PAY_PER_REQUEST --region us-east-1
aws iam create-role --role-name walkthrough-processor-role --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"Service":"lambda.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
aws iam attach-role-policy --role-name walkthrough-processor-role --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

pip install openai boto3 python-dotenv
echo 'OPENAI_API_KEY=sk-your-api-key-here' > .env

import openai, os
from dotenv import load_dotenv
load_dotenv()
client = openai.OpenAI()

# Test Whisper transcription with a sample file
with open('test_walkthrough.m4a', 'rb') as audio_file:
    transcript = client.audio.transcriptions.create(
        model='whisper-1',
        file=audio_file,
        response_format='verbose_json',
        timestamp_granularities=['segment']
    )
    print('Transcription successful:')
    print(transcript.text[:500])

mkdir -p walkthrough-processor && cd walkthrough-processor
pip install openai boto3 -t ./package
cd package && zip -r ../deployment.zip . && cd ..
zip deployment.zip lambda_function.py
aws lambda create-function --function-name walkthrough-transcribe --runtime python3.12 --handler lambda_function.transcribe_handler --role arn:aws:iam::ACCOUNT_ID:role/walkthrough-processor-role --zip-file fileb://deployment.zip --timeout 300 --memory-size 512 --environment 'Variables={OPENAI_API_KEY=sk-your-key,PUNCH_TABLE=client-name-punch-items}'
aws lambda create-function --function-name walkthrough-extract --runtime python3.12 --handler lambda_function.extract_handler --role arn:aws:iam::ACCOUNT_ID:role/walkthrough-processor-role --zip-file fileb://deployment.zip --timeout 120 --memory-size 256 --environment 'Variables={OPENAI_API_KEY=sk-your-key,PUNCH_TABLE=client-name-punch-items}'
aws s3api put-bucket-notification-configuration --bucket client-name-walkthrough-audio --notification-configuration '{"LambdaFunctionConfigurations":[{"LambdaFunctionArn":"arn:aws:lambda:us-east-1:ACCOUNT_ID:function:walkthrough-transcribe","Events":["s3:ObjectCreated:*"],"Filter":{"Key":{"FilterRules":[{"Name":"prefix","Value":"raw-audio/"},{"Name":"suffix","Value":".m4a"}]}}}]}'

# Python upload script for fleet phones via Termux or custom APK

import boto3, sys, os, uuid
from datetime import datetime

s3 = boto3.client('s3',
    aws_access_key_id=os.environ['AWS_ACCESS_KEY'],
    aws_secret_access_key=os.environ['AWS_SECRET_KEY']
)

file_path = sys.argv[1]
project_id = sys.argv[2] if len(sys.argv) > 2 else 'default'
walkthrough_id = f"{project_id}/{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"

s3.upload_file(
    file_path,
    'client-name-walkthrough-audio',
    f'raw-audio/{walkthrough_id}.m4a',
    ExtraArgs={'Metadata': {'project': project_id, 'superintendent': os.environ.get('USER_NAME', 'unknown')}}
)
print(f'Uploaded: {walkthrough_id}')

aws s3 mb s3://client-name-punch-dashboard --region us-east-1
aws s3 website s3://client-name-punch-dashboard --index-document index.html --error-document error.html
aws s3 sync ./dashboard-frontend/ s3://client-name-punch-dashboard/ --acl public-read

aws apigateway create-rest-api --name 'PunchListAPI' --description 'Walkthrough punch list API' --endpoint-configuration '{"types":["REGIONAL"]}'

aws cloudfront create-distribution --origin-domain-name client-name-punch-dashboard.s3-website-us-east-1.amazonaws.com --default-root-object index.html

pip install requests

# list projects to verify access

import requests

FIELDWIRE_API_TOKEN = 'your-fieldwire-api-token'
headers = {
    'Authorization': f'Bearer {FIELDWIRE_API_TOKEN}',
    'Content-Type': 'application/json'
}

# List projects to verify access
response = requests.get('https://clientapi.fieldwire.com/api/v3/projects', headers=headers)
print(f'Status: {response.status_code}')
for project in response.json():
    print(f'Project: {project["name"]} (ID: {project["id"]})')

import requests, json

FIELDWIRE_API_TOKEN = 'your-fieldwire-api-token'
PROJECT_ID = 'your-project-id'
headers = {
    'Authorization': f'Bearer {FIELDWIRE_API_TOKEN}',
    'Content-Type': 'application/json'
}

task_data = {
    'name': 'TEST - Kitchen faucet leaking at supply valve',
    'priority': 2,
    'status_id': 0,
    'creator_user_id': None,
    'location_id': None,
    'labels': ['Plumbing', 'Punch List', 'AI-Generated']
}

response = requests.post(
    f'https://clientapi.fieldwire.com/api/v3/projects/{PROJECT_ID}/tasks',
    headers=headers,
    json=task_data
)
print(f'Created task: {response.json()["id"]}')

python3 -c "
import requests

CLIENT_ID = 'your-procore-client-id'
CLIENT_SECRET = 'your-procore-client-secret'
REDIRECT_URI = 'https://your-dashboard-url/oauth/callback'
AUTH_CODE = 'code-from-oauth-redirect'

# Exchange auth code for access token
token_response = requests.post('https://login.procore.com/oauth/token', data={
    'grant_type': 'authorization_code',
    'code': AUTH_CODE,
    'client_id': CLIENT_ID,
    'client_secret': CLIENT_SECRET,
    'redirect_uri': REDIRECT_URI
})

 access_token = token_response.json()['access_token']
print(f'Access token obtained: {access_token[:20]}...')

# Create test punch item
headers = {'Authorization': f'Bearer {access_token}', 'Content-Type': 'application/json'}
company_id = 'your-company-id'
project_id = 'your-project-id'

punch_item = {
    'punch_item': {
        'name': 'TEST - Kitchen faucet leaking at supply valve',
        'description': 'AI-generated from walkthrough transcription. Superintendent noted active leak at supply valve under kitchen sink, third unit from left.',
        'priority': 'high',
        'punch_item_type': 'Plumbing',
        'location_id': None,
        'assignee_id': None
    }
}

response = requests.post(
    f'https://app.procore.com/rest/v1.0/projects/{project_id}/punch_items',
    headers=headers,
    json=punch_item
)
print(f'Created Procore punch item: {response.status_code}')
"

python3 -c "
import json

# Load AI-generated items and superintendent corrections
with open('pilot_results.json') as f:
    results = json.load(f)

total_items = 0
correct_trade = 0
correct_location = 0
correct_priority = 0
missed_items = 0
false_items = 0

for walkthrough in results['walkthroughs']:
    for item in walkthrough['items']:
        total_items += 1
        if item['ai_trade'] == item['corrected_trade']:
            correct_trade += 1
        if item['ai_location'] == item['corrected_location']:
            correct_location += 1
        if item['ai_priority'] == item['corrected_priority']:
            correct_priority += 1
    missed_items += walkthrough.get('missed_count', 0)
    false_items += walkthrough.get('false_positive_count', 0)

print(f'Total items: {total_items}')
print(f'Trade accuracy: {correct_trade/total_items*100:.1f}%')
print(f'Location accuracy: {correct_location/total_items*100:.1f}%')
print(f'Priority accuracy: {correct_priority/total_items*100:.1f}%')
print(f'Missed items: {missed_items}')
print(f'False positives: {false_items}')
print(f'Precision: {total_items/(total_items+false_items)*100:.1f}%')
print(f'Recall: {total_items/(total_items+missed_items)*100:.1f}%')
"

import json
import os
import boto3
import openai
import tempfile
import uuid
from datetime import datetime

s3 = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')
lambda_client = boto3.client('lambda')

OPENAI_API_KEY = os.environ['OPENAI_API_KEY']
PUNCH_TABLE = os.environ['PUNCH_TABLE']
BUCKET_NAME = os.environ.get('BUCKET_NAME', 'client-name-walkthrough-audio')

client = openai.OpenAI(api_key=OPENAI_API_KEY)

def transcribe_handler(event, context):
    """Triggered by S3 ObjectCreated event on raw-audio/ prefix."""
    
    record = event['Records'][0]
    bucket = record['s3']['bucket']['name']
    key = record['s3']['object']['key']
    
    # Extract metadata
    head_response = s3.head_object(Bucket=bucket, Key=key)
    metadata = head_response.get('Metadata', {})
    project_id = metadata.get('project', 'unknown')
    superintendent = metadata.get('superintendent', 'unknown')
    
    # Generate walkthrough ID
    walkthrough_id = key.replace('raw-audio/', '').replace('.m4a', '').replace('.mp3', '').replace('.wav', '')
    
    # Download audio to temp file
    with tempfile.NamedTemporaryFile(suffix='.m4a', delete=False) as tmp:
        s3.download_file(bucket, key, tmp.name)
        tmp_path = tmp.name
    
    try:
        # Check file size - Whisper API limit is 25MB
        file_size = os.path.getsize(tmp_path)
        
        if file_size > 25 * 1024 * 1024:
            # For files > 25MB, use chunked approach
            transcript_text = _transcribe_chunked(tmp_path)
        else:
            # Standard transcription
            with open(tmp_path, 'rb') as audio_file:
                transcript_response = client.audio.transcriptions.create(
                    model='whisper-1',
                    file=audio_file,
                    response_format='verbose_json',
                    timestamp_granularities=['segment'],
                    language='en',
                    prompt='Construction site walkthrough punch list narration. Trades include plumbing, electrical, HVAC, drywall, paint, flooring, carpentry, roofing, concrete, steel, fire protection, insulation, landscaping, doors, windows, hardware, appliances, countertops, cabinets, tile.'
                )
                transcript_text = transcript_response.text
                segments = transcript_response.segments if hasattr(transcript_response, 'segments') else []
        
        # Store transcript in S3
        transcript_key = f'transcripts/{walkthrough_id}.json'
        transcript_data = {
            'walkthrough_id': walkthrough_id,
            'project_id': project_id,
            'superintendent': superintendent,
            'timestamp': datetime.utcnow().isoformat(),
            'audio_key': key,
            'transcript': transcript_text,
            'segments': [{'start': s.start, 'end': s.end, 'text': s.text} for s in segments] if segments else [],
            'audio_duration_seconds': segments[-1].end if segments else None,
            'status': 'transcribed'
        }
        
        s3.put_object(
            Bucket=bucket,
            Key=transcript_key,
            Body=json.dumps(transcript_data, indent=2),
            ContentType='application/json'
        )
        
        # Trigger extraction function
        lambda_client.invoke(
            FunctionName='walkthrough-extract',
            InvocationType='Event',  # Async
            Payload=json.dumps({
                'walkthrough_id': walkthrough_id,
                'transcript_key': transcript_key,
                'bucket': bucket,
                'project_id': project_id,
                'superintendent': superintendent
            })
        )
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'walkthrough_id': walkthrough_id,
                'transcript_length': len(transcript_text),
                'status': 'transcribed_and_extraction_triggered'
            })
        }
        
    finally:
        os.unlink(tmp_path)


def _transcribe_chunked(file_path):
    """Handle files larger than 25MB by splitting with pydub."""
    from pydub import AudioSegment
    
    audio = AudioSegment.from_file(file_path)
    chunk_length_ms = 10 * 60 * 1000  # 10-minute chunks
    chunks = [audio[i:i + chunk_length_ms] for i in range(0, len(audio), chunk_length_ms)]
    
    full_transcript = []
    for i, chunk in enumerate(chunks):
        with tempfile.NamedTemporaryFile(suffix='.m4a', delete=False) as tmp:
            chunk.export(tmp.name, format='ipod')  # M4A format
            with open(tmp.name, 'rb') as chunk_file:
                response = client.audio.transcriptions.create(
                    model='whisper-1',
                    file=chunk_file,
                    response_format='text',
                    language='en',
                    prompt='Construction site walkthrough punch list narration. Continuing from previous segment.'
                )
                full_transcript.append(response)
            os.unlink(tmp.name)
    
    return ' '.join(full_transcript)

SYSTEM PROMPT:
---
You are a construction punch list extraction AI. You analyze transcripts of superintendent walkthrough narrations and extract individual punch list items.

For each issue or deficiency mentioned in the transcript, extract a structured punch list item.

## Output Format
Respond with valid JSON only. No markdown, no explanation. Use this exact schema:

{
  "walkthrough_summary": "Brief 1-2 sentence summary of the walkthrough scope",
  "total_items": <integer>,
  "items": [
    {
      "item_number": <sequential integer starting at 1>,
      "location": {
        "building": "<building name/number or null>",
        "floor": "<floor number/name or null>",
        "unit": "<unit number or null>",
        "room": "<room name: Kitchen, Master Bathroom, Hallway, etc.>",
        "detail": "<specific location detail: 'north wall', 'above entry door', 'third from left', etc.>"
      },
      "trade": "<one of the standard trades listed below>",
      "priority": "<one of: Life Safety | High | Medium | Low | Cosmetic>",
      "description": "<clear, actionable description of the deficiency>",
      "action_required": "<specific corrective action: Replace, Repair, Adjust, Clean, Install, Complete, Touch-up, etc.>",
      "notes": "<any additional context from the narration, or null>",
      "confidence": <float 0.0-1.0 indicating extraction confidence>
    }
  ],
  "ambiguous_mentions": [
    {
      "transcript_excerpt": "<the unclear portion of transcript>",
      "reason": "<why this couldn't be parsed as a punch item>"
    }
  ]
}

## Standard Trade Categories
Use EXACTLY one of these trade names (map superintendent's informal language to the closest match):
- Plumbing
- Electrical
- HVAC
- Drywall
- Paint
- Flooring
- Carpentry / Millwork
- Roofing
- Concrete
- Structural Steel
- Fire Protection
- Insulation
- Doors / Frames / Hardware
- Windows / Glazing
- Appliances
- Cabinets / Countertops
- Tile / Stone
- Landscaping / Sitework
- Elevator
- Low Voltage / AV
- Cleaning
- General / Other

## Priority Classification Guide
- **Life Safety**: Fire code violations, missing egress signage, exposed wiring, trip hazards in common areas, missing handrails, fire suppression deficiencies
- **High**: Active water leaks, HVAC not functioning, no hot water, broken locks, code violations that block inspection sign-off
- **Medium**: Cosmetic drywall damage visible at eye level, misaligned doors, improper caulking, fixture not level, minor plumbing drip
- **Low**: Minor paint touch-ups, small nail pops, slight grout discoloration, adjustable hardware items
- **Cosmetic**: Scuffs, cleaning items, protective film removal, minor blemishes only visible upon close inspection

## Extraction Rules
1. Each distinct deficiency is a separate item, even if mentioned in the same sentence
2. If the superintendent mentions location once and then lists multiple issues, apply that location to all subsequent items until a new location is stated
3. If trade is not explicitly stated, infer from the description (e.g., 'leaking faucet' = Plumbing)
4. If priority is not explicitly stated, infer from the severity using the classification guide above
5. Convert informal language to professional descriptions (e.g., 'this thing is messed up' → describe the actual deficiency based on context)
6. Ignore non-punch-list narration (greetings, phone calls, casual conversation, project status updates)
7. If the superintendent says 'same as before' or 'same issue', create a new item with the previous item's trade and description but the current location
8. Flag items with confidence < 0.6 — these need superintendent review
9. Preserve any specific measurements, counts, or unit identifiers mentioned ('third unit from left', '6-inch gap', 'both bathrooms')
10. If a single mention implies multiple items (e.g., 'all six units need paint touch-up in kitchen'), create one item with the quantity noted in the description

## Client-Specific Customization
<!-- MSP: Replace the section below with client-specific terms during pilot calibration -->
- Location hierarchy: [Building Name/Number] > [Floor] > [Unit Number] > [Room]
- Client calls HVAC: "mechanical" — map to HVAC
- Client uses priority: "urgent" — map to High
- Client uses priority: "whenever" or "low priority" — map to Low
- Common abbreviations: "MBR" = Master Bedroom, "MBA" = Master Bathroom, "LR" = Living Room, "KIT" = Kitchen, "GR" = Great Room
---

USER PROMPT:
---
Extract all punch list items from the following construction walkthrough transcript.

Project: {{project_name}}
Date: {{walkthrough_date}}
Superintendent: {{superintendent_name}}

Transcript:
{{transcript_text}}
---

import json
import os
import boto3
import openai
from datetime import datetime
from decimal import Decimal

s3 = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['PUNCH_TABLE'])

OPENAI_API_KEY = os.environ['OPENAI_API_KEY']
client = openai.OpenAI(api_key=OPENAI_API_KEY)

# Load the system prompt from environment or S3
SYSTEM_PROMPT_KEY = os.environ.get('SYSTEM_PROMPT_KEY', 'config/extraction_prompt.txt')

VALID_TRADES = [
    'Plumbing', 'Electrical', 'HVAC', 'Drywall', 'Paint', 'Flooring',
    'Carpentry / Millwork', 'Roofing', 'Concrete', 'Structural Steel',
    'Fire Protection', 'Insulation', 'Doors / Frames / Hardware',
    'Windows / Glazing', 'Appliances', 'Cabinets / Countertops',
    'Tile / Stone', 'Landscaping / Sitework', 'Elevator',
    'Low Voltage / AV', 'Cleaning', 'General / Other'
]

VALID_PRIORITIES = ['Life Safety', 'High', 'Medium', 'Low', 'Cosmetic']


def extract_handler(event, context):
    """Process transcript and extract structured punch list items."""
    
    walkthrough_id = event['walkthrough_id']
    transcript_key = event['transcript_key']
    bucket = event['bucket']
    project_id = event.get('project_id', 'unknown')
    superintendent = event.get('superintendent', 'unknown')
    
    # Load transcript
    transcript_obj = s3.get_object(Bucket=bucket, Key=transcript_key)
    transcript_data = json.loads(transcript_obj['Body'].read().decode('utf-8'))
    transcript_text = transcript_data['transcript']
    
    # Load system prompt
    try:
        prompt_obj = s3.get_object(Bucket=bucket, Key=SYSTEM_PROMPT_KEY)
        system_prompt = prompt_obj['Body'].read().decode('utf-8')
    except Exception:
        system_prompt = DEFAULT_SYSTEM_PROMPT  # Fallback to hardcoded prompt
    
    # Build user message
    user_message = f"""Extract all punch list items from the following construction walkthrough transcript.

Project: {project_id}
Date: {datetime.utcnow().strftime('%Y-%m-%d')}
Superintendent: {superintendent}

Transcript:
{transcript_text}"""
    
    # Call GPT-5.4 mini with retry logic
    max_retries = 3
    extracted_data = None
    
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model='gpt-5.4-mini',
                messages=[
                    {'role': 'system', 'content': system_prompt},
                    {'role': 'user', 'content': user_message}
                ],
                temperature=0.1,  # Low temperature for consistent extraction
                max_tokens=8000,
                response_format={'type': 'json_object'}
            )
            
            raw_response = response.choices[0].message.content
            extracted_data = json.loads(raw_response)
            
            # Validate structure
            if 'items' not in extracted_data:
                raise ValueError('Response missing "items" key')
            
            # Validate and clean each item
            for item in extracted_data['items']:
                if item.get('trade') not in VALID_TRADES:
                    item['trade'] = 'General / Other'
                    item['notes'] = (item.get('notes') or '') + f' [Original trade: {item.get("trade", "unknown")}]'
                if item.get('priority') not in VALID_PRIORITIES:
                    item['priority'] = 'Medium'
                item['confidence'] = item.get('confidence', 0.8)
            
            break  # Success
            
        except (json.JSONDecodeError, ValueError, KeyError) as e:
            if attempt < max_retries - 1:
                continue
            else:
                extracted_data = {
                    'walkthrough_summary': 'Extraction failed - manual review required',
                    'total_items': 0,
                    'items': [],
                    'error': str(e),
                    'raw_response': raw_response if 'raw_response' in dir() else None
                }
    
    # Store items in DynamoDB
    timestamp = datetime.utcnow().isoformat()
    
    with table.batch_writer() as batch:
        # Write walkthrough metadata
        batch.put_item(Item={
            'walkthrough_id': walkthrough_id,
            'item_id': 'METADATA',
            'project_id': project_id,
            'superintendent': superintendent,
            'timestamp': timestamp,
            'summary': extracted_data.get('walkthrough_summary', ''),
            'total_items': extracted_data.get('total_items', 0),
            'status': 'pending_review',
            'ambiguous_mentions': json.dumps(extracted_data.get('ambiguous_mentions', []))
        })
        
        # Write each punch item
        for item in extracted_data.get('items', []):
            item_id = f"ITEM#{item['item_number']:04d}"
            batch.put_item(Item={
                'walkthrough_id': walkthrough_id,
                'item_id': item_id,
                'item_number': item['item_number'],
                'location': json.dumps(item.get('location', {})),
                'trade': item['trade'],
                'priority': item['priority'],
                'description': item['description'],
                'action_required': item.get('action_required', 'Review'),
                'notes': item.get('notes'),
                'confidence': Decimal(str(item.get('confidence', 0.8))),
                'status': 'pending_review',
                'approved': False,
                'created_at': timestamp,
                'updated_at': timestamp
            })
    
    # Store full extraction result in S3
    extraction_key = f'extractions/{walkthrough_id}.json'
    s3.put_object(
        Bucket=bucket,
        Key=extraction_key,
        Body=json.dumps({
            'walkthrough_id': walkthrough_id,
            'project_id': project_id,
            'superintendent': superintendent,
            'extraction_timestamp': timestamp,
            'extracted_data': extracted_data,
            'model': 'gpt-5.4-mini',
            'prompt_version': '1.0'
        }, indent=2, default=str),
        ContentType='application/json'
    )
    
    # Update transcript status
    transcript_data['status'] = 'extracted'
    transcript_data['extraction_key'] = extraction_key
    transcript_data['item_count'] = len(extracted_data.get('items', []))
    s3.put_object(
        Bucket=bucket,
        Key=transcript_key,
        Body=json.dumps(transcript_data, indent=2),
        ContentType='application/json'
    )
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'walkthrough_id': walkthrough_id,
            'items_extracted': len(extracted_data.get('items', [])),
            'ambiguous_mentions': len(extracted_data.get('ambiguous_mentions', [])),
            'status': 'pending_review'
        })
    }


DEFAULT_SYSTEM_PROMPT = """You are a construction punch list extraction AI. You analyze transcripts of superintendent walkthrough narrations and extract individual punch list items. Respond with valid JSON containing a 'walkthrough_summary', 'total_items' count, 'items' array with item_number, location (building/floor/unit/room/detail), trade, priority (Life Safety/High/Medium/Low/Cosmetic), description, action_required, notes, and confidence score, plus an 'ambiguous_mentions' array for unclear portions."""

import json
import os
import requests
import boto3
from datetime import datetime

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['PUNCH_TABLE'])

FIELDWIRE_API_TOKEN = os.environ['FIELDWIRE_API_TOKEN']
FIELDWIRE_BASE_URL = 'https://clientapi.fieldwire.com/api/v3'

# Priority mapping: AI priority -> Fieldwire priority (1=High, 2=Normal, 3=Low)
PRIORITY_MAP = {
    'Life Safety': 1,
    'High': 1,
    'Medium': 2,
    'Low': 3,
    'Cosmetic': 3
}

def push_to_fieldwire(event, context):
    """Push approved punch list items to Fieldwire as tasks."""
    
    walkthrough_id = event['walkthrough_id']
    project_id_fieldwire = event['fieldwire_project_id']
    
    headers = {
        'Authorization': f'Bearer {FIELDWIRE_API_TOKEN}',
        'Content-Type': 'application/json'
    }
    
    # Query approved items from DynamoDB
    response = table.query(
        KeyConditionExpression='walkthrough_id = :wid',
        FilterExpression='approved = :approved AND begins_with(item_id, :prefix)',
        ExpressionAttributeValues={
            ':wid': walkthrough_id,
            ':approved': True,
            ':prefix': 'ITEM#'
        }
    )
    
    items = response['Items']
    created_tasks = []
    errors = []
    
    # Get existing categories (trades) in the Fieldwire project
    categories_response = requests.get(
        f'{FIELDWIRE_BASE_URL}/projects/{project_id_fieldwire}/categories',
        headers=headers
    )
    existing_categories = {c['name']: c['id'] for c in categories_response.json()}
    
    for item in items:
        location = json.loads(item.get('location', '{}'))
        
        # Build task name: [Priority] Location - Description
        location_parts = [v for v in [location.get('building'), location.get('floor'), 
                                       location.get('unit'), location.get('room'),
                                       location.get('detail')] if v]
        location_str = ', '.join(location_parts) if location_parts else 'Location TBD'
        
        task_name = f"[{item['priority']}] {location_str} - {item['description'][:100]}"
        
        # Ensure trade category exists
        trade = item.get('trade', 'General / Other')
        if trade not in existing_categories:
            cat_response = requests.post(
                f'{FIELDWIRE_BASE_URL}/projects/{project_id_fieldwire}/categories',
                headers=headers,
                json={'name': trade, 'color': '#FF6B35'}  # Orange for punch items
            )
            if cat_response.status_code == 200:
                existing_categories[trade] = cat_response.json()['id']
        
        task_data = {
            'name': task_name,
            'priority': PRIORITY_MAP.get(item.get('priority', 'Medium'), 2),
            'status_id': 0,  # 0 = Open
            'category_id': existing_categories.get(trade),
            'labels': ['Punch List', 'AI-Generated', item.get('priority', 'Medium')],
            'description': (
                f"Trade: {trade}\n"
                f"Location: {location_str}\n"
                f"Priority: {item.get('priority', 'Medium')}\n"
                f"Action Required: {item.get('action_required', 'Review')}\n"
                f"Description: {item.get('description', '')}\n"
                f"{'Notes: ' + item.get('notes') if item.get('notes') else ''}\n"
                f"---\n"
                f"AI Confidence: {float(item.get('confidence', 0)):.0%}\n"
                f"Source: Walkthrough {walkthrough_id}\n"
                f"Generated: {item.get('created_at', '')}"
            )
        }
        
        try:
            task_response = requests.post(
                f'{FIELDWIRE_BASE_URL}/projects/{project_id_fieldwire}/tasks',
                headers=headers,
                json=task_data
            )
            
            if task_response.status_code in [200, 201]:
                fieldwire_task_id = task_response.json()['id']
                created_tasks.append({
                    'item_id': item['item_id'],
                    'fieldwire_task_id': fieldwire_task_id
                })
                
                # Update DynamoDB with Fieldwire task ID
                table.update_item(
                    Key={'walkthrough_id': walkthrough_id, 'item_id': item['item_id']},
                    UpdateExpression='SET fieldwire_task_id = :tid, pushed_at = :ts',
                    ExpressionAttributeValues={
                        ':tid': fieldwire_task_id,
                        ':ts': datetime.utcnow().isoformat()
                    }
                )
            else:
                errors.append({
                    'item_id': item['item_id'],
                    'error': task_response.text,
                    'status_code': task_response.status_code
                })
                
        except Exception as e:
            errors.append({'item_id': item['item_id'], 'error': str(e)})
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'walkthrough_id': walkthrough_id,
            'tasks_created': len(created_tasks),
            'errors': len(errors),
            'created_tasks': created_tasks,
            'error_details': errors
        })
    }

import json
import os
import boto3
from datetime import datetime
from weasyprint import HTML
from collections import defaultdict

s3 = boto3.client('s3')
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['PUNCH_TABLE'])

def generate_pdf_handler(event, context):
    """Generate PDF punch list report from approved items."""
    
    walkthrough_id = event['walkthrough_id']
    client_name = event.get('client_name', 'Construction Client')
    project_name = event.get('project_name', 'Project')
    
    # Query all items
    response = table.query(
        KeyConditionExpression='walkthrough_id = :wid',
        ExpressionAttributeValues={':wid': walkthrough_id}
    )
    
    metadata = None
    items = []
    for record in response['Items']:
        if record['item_id'] == 'METADATA':
            metadata = record
        elif record['item_id'].startswith('ITEM#'):
            items.append(record)
    
    # Group by trade
    by_trade = defaultdict(list)
    for item in sorted(items, key=lambda x: x.get('item_number', 0)):
        by_trade[item.get('trade', 'General / Other')].append(item)
    
    # Priority counts
    priority_counts = defaultdict(int)
    for item in items:
        priority_counts[item.get('priority', 'Medium')] += 1
    
    # Build HTML
    trade_sections = ''
    for trade in sorted(by_trade.keys()):
        trade_items = by_trade[trade]
        rows = ''
        for item in trade_items:
            location = json.loads(item.get('location', '{}'))
            loc_parts = [v for v in [location.get('unit'), location.get('room'), location.get('detail')] if v]
            loc_str = ', '.join(loc_parts) if loc_parts else 'TBD'
            priority = item.get('priority', 'Medium')
            priority_class = priority.lower().replace(' ', '-')
            rows += f"""
            <tr>
                <td>{item.get('item_number', '')}</td>
                <td>{loc_str}</td>
                <td class="priority-{priority_class}">{priority}</td>
                <td>{item.get('description', '')}</td>
                <td>{item.get('action_required', '')}</td>
                <td class="status-cell">☐ Open</td>
            </tr>"""
        
        trade_sections += f"""
        <div class="trade-section">
            <h2>{trade} ({len(trade_items)} items)</h2>
            <table>
                <thead>
                    <tr><th>#</th><th>Location</th><th>Priority</th><th>Description</th><th>Action</th><th>Status</th></tr>
                </thead>
                <tbody>{rows}</tbody>
            </table>
        </div>"""
    
    html_content = f"""
    <!DOCTYPE html>
    <html>
    <head>
        <style>
            body {{ font-family: Arial, sans-serif; font-size: 10pt; margin: 20mm; }}
            h1 {{ color: #1a1a2e; border-bottom: 3px solid #e94560; padding-bottom: 10px; }}
            h2 {{ color: #1a1a2e; background: #f0f0f0; padding: 8px 12px; margin-top: 20px; }}
            table {{ width: 100%; border-collapse: collapse; margin-bottom: 15px; }}
            th {{ background: #1a1a2e; color: white; padding: 6px 8px; text-align: left; font-size: 9pt; }}
            td {{ border: 1px solid #ddd; padding: 5px 8px; font-size: 9pt; vertical-align: top; }}
            tr:nth-child(even) {{ background: #f9f9f9; }}
            .summary-box {{ background: #f0f4f8; border: 1px solid #d0d8e0; padding: 15px; margin: 15px 0; }}
            .summary-box span {{ margin-right: 20px; font-weight: bold; }}
            .priority-life-safety {{ color: #d32f2f; font-weight: bold; }}
            .priority-high {{ color: #e65100; font-weight: bold; }}
            .priority-medium {{ color: #f57f17; }}
            .priority-low {{ color: #2e7d32; }}
            .priority-cosmetic {{ color: #757575; }}
            .status-cell {{ text-align: center; }}
            .footer {{ margin-top: 30px; border-top: 1px solid #ccc; padding-top: 15px; font-size: 9pt; color: #666; }}
            .signoff {{ margin-top: 40px; }}
            .signoff-line {{ border-bottom: 1px solid #333; width: 250px; display: inline-block; margin: 0 20px; }}
            @page {{ @bottom-right {{ content: "Page " counter(page) " of " counter(pages); font-size: 8pt; }} }}
        </style>
    </head>
    <body>
        <h1>{client_name}<br/><small style="font-size:14pt;color:#666;">{project_name} — Punch List</small></h1>
        
        <div class="summary-box">
            <strong>Date:</strong> {datetime.utcnow().strftime('%B %d, %Y')}&nbsp;&nbsp;|&nbsp;&nbsp;
            <strong>Superintendent:</strong> {metadata.get('superintendent', 'N/A') if metadata else 'N/A'}&nbsp;&nbsp;|&nbsp;&nbsp;
            <strong>Total Items:</strong> {len(items)}&nbsp;&nbsp;|&nbsp;&nbsp;
            <span style="color:#d32f2f;">Life Safety: {priority_counts.get('Life Safety', 0)}</span>
            <span style="color:#e65100;">High: {priority_counts.get('High', 0)}</span>
            <span style="color:#f57f17;">Medium: {priority_counts.get('Medium', 0)}</span>
            <span style="color:#2e7d32;">Low: {priority_counts.get('Low', 0)}</span>
            <span style="color:#757575;">Cosmetic: {priority_counts.get('Cosmetic', 0)}</span>
        </div>
        
        {trade_sections}
        
        <div class="signoff">
            <p><strong>Reviewed and Approved By:</strong></p>
            <p>Superintendent: <span class="signoff-line"></span> Date: <span class="signoff-line" style="width:120px;"></span></p>
            <p>Project Manager: <span class="signoff-line"></span> Date: <span class="signoff-line" style="width:120px;"></span></p>
        </div>
        
        <div class="footer">
            <p>Generated by AI transcription system — reviewed and approved by superintendent prior to distribution.</p>
            <p>Walkthrough ID: {walkthrough_id} | Generated: {datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC')}</p>
        </div>
    </body>
    </html>"""
    
    # Generate PDF
    pdf_bytes = HTML(string=html_content).write_pdf()
    
    # Upload to S3
    pdf_key = f'reports/{walkthrough_id}_punch_list.pdf'
    bucket = os.environ.get('BUCKET_NAME', 'client-name-walkthrough-audio')
    s3.put_object(
        Bucket=bucket,
        Key=pdf_key,
        Body=pdf_bytes,
        ContentType='application/pdf'
    )
    
    # Generate pre-signed URL for download (valid 7 days)
    download_url = s3.generate_presigned_url(
        'get_object',
        Params={'Bucket': bucket, 'Key': pdf_key},
        ExpiresIn=604800
    )
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'pdf_key': pdf_key,
            'download_url': download_url,
            'total_items': len(items),
            'trades': len(by_trade)
        })
    }

<!-- Main dashboard. Deploy to S3 bucket as static website. -->

<!-- index.html - Main dashboard -->
<!-- Deploy to S3 bucket as static website -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <title>Walkthrough Punch List</title>
    <style>
        * { box-sizing: border-box; margin: 0; padding: 0; }
        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #f5f5f5; }
        .header { background: #1a1a2e; color: white; padding: 16px; display: flex; justify-content: space-between; align-items: center; }
        .header h1 { font-size: 18px; }
        .container { max-width: 800px; margin: 0 auto; padding: 16px; }
        
        /* Upload Section */
        .upload-zone { background: white; border: 3px dashed #ccc; border-radius: 12px; padding: 40px 20px; text-align: center; margin: 16px 0; cursor: pointer; transition: all 0.3s; }
        .upload-zone:hover, .upload-zone.dragover { border-color: #e94560; background: #fff5f7; }
        .upload-zone input[type="file"] { display: none; }
        .upload-btn { background: #e94560; color: white; border: none; padding: 16px 32px; border-radius: 8px; font-size: 18px; cursor: pointer; min-height: 56px; min-width: 200px; }
        .upload-btn:disabled { background: #ccc; }
        
        /* Project selector */
        select, input[type="text"] { width: 100%; padding: 12px; border: 1px solid #ddd; border-radius: 8px; font-size: 16px; margin: 8px 0; }
        
        /* Walkthrough list */
        .walkthrough-card { background: white; border-radius: 8px; padding: 16px; margin: 12px 0; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
        .walkthrough-card h3 { font-size: 16px; margin-bottom: 8px; }
        .status-badge { display: inline-block; padding: 4px 12px; border-radius: 12px; font-size: 12px; font-weight: bold; }
        .status-processing { background: #fff3cd; color: #856404; }
        .status-review { background: #d4edda; color: #155724; }
        .status-approved { background: #cce5ff; color: #004085; }
        
        /* Punch item list */
        .punch-item { border-left: 4px solid #ccc; padding: 12px; margin: 8px 0; background: #fafafa; border-radius: 0 8px 8px 0; }
        .punch-item.priority-high, .punch-item.priority-life-safety { border-left-color: #d32f2f; }
        .punch-item.priority-medium { border-left-color: #f57f17; }
        .punch-item.priority-low, .punch-item.priority-cosmetic { border-left-color: #4caf50; }
        .punch-item .trade-tag { background: #e3f2fd; color: #1565c0; padding: 2px 8px; border-radius: 4px; font-size: 12px; }
        .punch-item .location { color: #666; font-size: 13px; }
        
        /* Action buttons - large touch targets for field use */
        .action-btn { min-height: 44px; min-width: 44px; padding: 10px 20px; border: none; border-radius: 8px; font-size: 14px; cursor: pointer; margin: 4px; }
        .btn-approve { background: #4caf50; color: white; }
        .btn-reject { background: #f44336; color: white; }
        .btn-edit { background: #2196f3; color: white; }
        .btn-export { background: #1a1a2e; color: white; }
        
        /* Progress bar */
        .progress { height: 8px; background: #e0e0e0; border-radius: 4px; overflow: hidden; margin: 8px 0; }
        .progress-bar { height: 100%; background: #4caf50; transition: width 0.5s; }
        
        /* Loading spinner */
        .spinner { border: 3px solid #f3f3f3; border-top: 3px solid #e94560; border-radius: 50%; width: 24px; height: 24px; animation: spin 1s linear infinite; display: inline-block; }
        @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
    </style>
</head>
<body>
    <div class="header">
        <h1>🏗️ Punch List AI</h1>
        <span id="user-name">Superintendent</span>
    </div>
    
    <div class="container">
        <!-- Upload Section -->
        <div class="upload-zone" id="upload-zone" onclick="document.getElementById('file-input').click()">
            <input type="file" id="file-input" accept="audio/*,video/*" multiple>
            <p style="font-size: 24px; margin-bottom: 12px;">🎤</p>
            <p style="font-size: 16px; font-weight: bold;">Tap to upload walkthrough audio</p>
            <p style="color: #999; margin-top: 8px;">M4A, MP3, WAV, MP4 supported</p>
        </div>
        
        <select id="project-select">
            <option value="">Select Project...</option>
            <!-- Populated dynamically from API -->
        </select>
        
        <div id="upload-progress" style="display:none;">
            <p>Uploading... <span class="spinner"></span></p>
            <div class="progress"><div class="progress-bar" id="progress-bar"></div></div>
        </div>
        
        <!-- Walkthroughs List -->
        <h2 style="margin: 20px 0 12px; font-size: 18px;">Recent Walkthroughs</h2>
        <div id="walkthroughs-list">
            <!-- Populated dynamically -->
        </div>
    </div>
    
    <script>
        const API_BASE = '{{API_GATEWAY_URL}}'; // Replace during deployment
        const BUCKET = '{{S3_BUCKET}}'; // Replace during deployment
        
        // File upload handler
        document.getElementById('file-input').addEventListener('change', async (e) => {
            const files = e.target.files;
            const project = document.getElementById('project-select').value;
            if (!project) { alert('Please select a project first'); return; }
            
            for (const file of files) {
                await uploadFile(file, project);
            }
        });
        
        // Drag and drop
        const zone = document.getElementById('upload-zone');
        zone.addEventListener('dragover', (e) => { e.preventDefault(); zone.classList.add('dragover'); });
        zone.addEventListener('dragleave', () => zone.classList.remove('dragover'));
        zone.addEventListener('drop', async (e) => {
            e.preventDefault(); zone.classList.remove('dragover');
            const project = document.getElementById('project-select').value;
            if (!project) { alert('Please select a project first'); return; }
            for (const file of e.dataTransfer.files) { await uploadFile(file, project); }
        });
        
        async function uploadFile(file, project) {
            document.getElementById('upload-progress').style.display = 'block';
            
            // Get pre-signed upload URL from API
            const urlResp = await fetch(`${API_BASE}/upload-url`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ filename: file.name, project: project, content_type: file.type })
            });
            const { upload_url, walkthrough_id } = await urlResp.json();
            
            // Upload to S3
            const xhr = new XMLHttpRequest();
            xhr.upload.onprogress = (e) => {
                if (e.lengthComputable) {
                    document.getElementById('progress-bar').style.width = (e.loaded/e.total*100) + '%';
                }
            };
            xhr.onload = () => {
                document.getElementById('upload-progress').style.display = 'none';
                alert('Upload complete! Processing will take 2-5 minutes.');
                loadWalkthroughs();
            };
            xhr.open('PUT', upload_url);
            xhr.setRequestHeader('Content-Type', file.type);
            xhr.send(file);
        }
        
        async function loadWalkthroughs() {
            const resp = await fetch(`${API_BASE}/walkthroughs`);
            const walkthroughs = await resp.json();
            
            const list = document.getElementById('walkthroughs-list');
            list.innerHTML = walkthroughs.map(w => `
                <div class="walkthrough-card">
                    <h3>${w.project_id} — ${new Date(w.timestamp).toLocaleDateString()}</h3>
                    <span class="status-badge status-${w.status === 'pending_review' ? 'review' : w.status}">${w.status.replace('_', ' ')}</span>
                    <span style="float:right;">${w.total_items} items</span>
                    <p style="margin-top:8px;color:#666;">By: ${w.superintendent}</p>
                    ${w.status === 'pending_review' ? `<button class="action-btn btn-approve" onclick="reviewWalkthrough('${w.walkthrough_id}')">Review Items →</button>` : ''}
                    ${w.status === 'approved' ? `<button class="action-btn btn-export" onclick="exportPDF('${w.walkthrough_id}')">📄 Export PDF</button> <button class="action-btn btn-approve" onclick="pushToFieldwire('${w.walkthrough_id}')">Push to Fieldwire</button>` : ''}
                </div>
            `).join('');
        }
        
        async function reviewWalkthrough(id) {
            const resp = await fetch(`${API_BASE}/walkthroughs/${id}/items`);
            const items = await resp.json();
            // Render review interface with approve/reject/edit for each item
            // Implementation continues with item-level review UI
        }
        
        async function exportPDF(id) {
            const resp = await fetch(`${API_BASE}/walkthroughs/${id}/pdf`, { method: 'POST' });
            const { download_url } = await resp.json();
            window.open(download_url, '_blank');
        }
        
        async function pushToFieldwire(id) {
            if (!confirm('Push all approved items to Fieldwire?')) return;
            const resp = await fetch(`${API_BASE}/walkthroughs/${id}/push/fieldwire`, { method: 'POST' });
            const result = await resp.json();
            alert(`Created ${result.tasks_created} tasks in Fieldwire. ${result.errors} errors.`);
        }
        
        // Load data on page load
        loadWalkthroughs();
    </script>
</body>
</html>

"OK so we're in uh unit 302 now, the kitchen... the faucet's dripping again, same as 301. And the, uh, hold on... *phone rings* ...yeah no I'll call you back... OK where was I. Right, the backsplash tile in the kitchen here has a crack, about 6 inches long, near the outlet. Oh and the outlet cover is missing too. Moving to the master bath..."

1. Unit 302, Kitchen | Plumbing | Faucet dripping (same issue as Unit 301)
2. Unit 302, Kitchen | Tile | Backsplash tile cracked, approximately 6 inches long, near the electrical outlet
3. Unit 302, Kitchen | Electrical | Outlet cover plate missing (near backsplash)
4. Unit 302, Master Bathroom | [continues...]

aws s3api get-bucket-lifecycle-configuration --bucket client-name-walkthrough-audio