Implementation Guide: Transcribe daily production standup meetings and generate shift handoff notes

winget install Python.Python.3.11

python --version
pip --version

pip install deepgram-sdk openai python-dotenv sounddevice soundfile numpy requests msal

python -c "import sounddevice as sd; print(sd.query_devices())"

python -c "import sounddevice as sd; import soundfile as sf; data = sd.rec(int(5*16000), samplerate=16000, channels=1, device=2); sd.wait(); sf.write('test.wav', data, 16000); print('Test recording saved.')"

mkdir C:\StandupCapture
cd C:\StandupCapture

echo DEEPGRAM_API_KEY=your_deepgram_key_here > .env
echo OPENAI_API_KEY=your_openai_key_here >> .env
echo AUDIO_DEVICE_INDEX=2 >> .env
echo RECORDING_DURATION_MINUTES=20 >> .env
echo SAMPLE_RATE=16000 >> .env
echo SHAREPOINT_SITE_ID=your_sharepoint_site_id >> .env
echo SHAREPOINT_TENANT_ID=your_tenant_id >> .env
echo SHAREPOINT_CLIENT_ID=your_app_client_id >> .env
echo SHAREPOINT_CLIENT_SECRET=your_app_client_secret >> .env
echo TEAMS_WEBHOOK_URL=https://clientdomain.webhook.office.com/webhookb2/xxx >> .env
echo STANDUP_SCHEDULE=06:45,14:45,22:45 >> .env
echo MAX_RECORDING_MINUTES=30 >> .env
echo OUTPUT_DIR=C:\StandupCapture\recordings >> .env

icacls .env /inheritance:r /grant:r "%USERNAME%:F" /grant:r "SYSTEM:F"

mkdir recordings
mkdir transcripts
mkdir handoff_notes

echo deepgram-sdk==3.4.0 > requirements.txt
echo openai==1.40.0 >> requirements.txt
echo python-dotenv==1.0.1 >> requirements.txt
echo sounddevice==0.4.7 >> requirements.txt
echo soundfile==0.12.1 >> requirements.txt
echo numpy==1.26.4 >> requirements.txt
echo requests==2.32.3 >> requirements.txt
echo msal==1.28.0 >> requirements.txt
echo schedule==1.2.2 >> requirements.txt

pip install -r requirements.txt

python capture_agent.py --test --duration 60

nssm install StandupCaptureAgent "C:\Python311\python.exe" "C:\StandupCapture\capture_agent.py --service"
nssm set StandupCaptureAgent AppDirectory "C:\StandupCapture"
nssm set StandupCaptureAgent Start SERVICE_AUTO_START
nssm set StandupCaptureAgent AppStdout "C:\StandupCapture\logs\service.log"
nssm set StandupCaptureAgent AppStderr "C:\StandupCapture\logs\error.log"
nssm start StandupCaptureAgent

schtasks /create /tn "StandupCapture-Morning" /tr "C:\Python311\python.exe C:\StandupCapture\capture_agent.py --once" /sc daily /st 06:45 /ru SYSTEM

schtasks /create /tn "StandupCapture-Afternoon" /tr "C:\Python311\python.exe C:\StandupCapture\capture_agent.py --once" /sc daily /st 14:45 /ru SYSTEM

schtasks /create /tn "StandupCapture-Night" /tr "C:\Python311\python.exe C:\StandupCapture\capture_agent.py --once" /sc daily /st 22:45 /ru SYSTEM

schtasks /query /tn "StandupCapture-Morning" /v

keywords = [
  'CNC:2', 'PLC:2', 'OEE:2', 'TPM:1.5',
  'changeover:1.5', 'downtime:2', 'scrap rate:2',
  'first pass yield:2', 'cycle time:1.5',
  'work order:1.5', 'lot number:2', 'batch:1.5',
  'preventive maintenance:1.5', 'lockout tagout:2',
  'PPE:2', 'near miss:2', 'safety incident:2',
  'quality hold:2', 'nonconformance:2',
  # Add client-specific terms:
  'Line 1:1.5', 'Line 2:1.5', 'Line 3:1.5',
  'Robot Cell A:1.5', 'Fanuc:1.5', 'Haas:1.5',
  # Add product names, part numbers, etc.
]

# Speaker diarization settings:
# diarize=True, diarize_version='latest',
# utterances=True, detect_language=True

# maps Deepgram speaker labels to actual attendee names

{
  "Speaker 0": "Mike R. (Day Shift Supervisor)",
  "Speaker 1": "Sarah L. (Night Shift Supervisor)",
  "Speaker 2": "Tom K. (Maintenance Lead)",
  "Speaker 3": "Jenny W. (Quality Manager)"
}

python capture_agent.py --once --verbose

# Full recording, transcription, summarization, and delivery pipeline

#!/usr/bin/env python3
"""Standup Meeting Capture Agent for Manufacturing Shift Handoffs."""

import os
import sys
import json
import logging
import argparse
import time
from datetime import datetime, timedelta
from pathlib import Path

import numpy as np
import sounddevice as sd
import soundfile as sf
import schedule
from dotenv import load_dotenv
from deepgram import DeepgramClient, PrerecordedOptions, FileSource

from summarizer import generate_handoff_note
from delivery import post_to_teams, upload_to_sharepoint

# Load environment
load_dotenv()

# Configuration
AUDIO_DEVICE_INDEX = int(os.getenv('AUDIO_DEVICE_INDEX', '2'))
SAMPLE_RATE = int(os.getenv('SAMPLE_RATE', '16000'))
MAX_RECORDING_MINUTES = int(os.getenv('MAX_RECORDING_MINUTES', '30'))
SILENCE_THRESHOLD = 0.01  # RMS threshold for silence detection
SILENCE_TIMEOUT_SECONDS = 120  # Stop after 2 min continuous silence
OUTPUT_DIR = Path(os.getenv('OUTPUT_DIR', './recordings'))
TRANSCRIPT_DIR = Path('./transcripts')
HANDOFF_DIR = Path('./handoff_notes')
LOG_DIR = Path('./logs')

# Ensure directories exist
for d in [OUTPUT_DIR, TRANSCRIPT_DIR, HANDOFF_DIR, LOG_DIR]:
    d.mkdir(parents=True, exist_ok=True)

# Logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler(LOG_DIR / 'capture_agent.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)


def get_shift_name() -> str:
    """Determine current shift based on time of day."""
    hour = datetime.now().hour
    if 5 <= hour < 13:
        return 'day'
    elif 13 <= hour < 21:
        return 'afternoon'
    else:
        return 'night'


def record_meeting(duration_minutes: int = None) -> Path:
    """Record audio from the Jabra speakerphone with silence detection."""
    duration = duration_minutes or MAX_RECORDING_MINUTES
    max_samples = int(duration * 60 * SAMPLE_RATE)
    
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    shift = get_shift_name()
    filename = OUTPUT_DIR / f'standup_{shift}_{timestamp}.wav'
    
    logger.info(f'Starting recording: {filename} (max {duration} min, device {AUDIO_DEVICE_INDEX})')
    
    # Record in chunks for silence detection
    chunk_duration = 5  # seconds per chunk
    chunk_samples = int(chunk_duration * SAMPLE_RATE)
    all_audio = []
    silence_start = None
    recording_started = False
    
    try:
        total_recorded = 0
        while total_recorded < max_samples:
            chunk = sd.rec(
                chunk_samples,
                samplerate=SAMPLE_RATE,
                channels=1,
                dtype='float32',
                device=AUDIO_DEVICE_INDEX
            )
            sd.wait()
            
            rms = np.sqrt(np.mean(chunk**2))
            
            if rms > SILENCE_THRESHOLD:
                recording_started = True
                silence_start = None
                all_audio.append(chunk)
                total_recorded += chunk_samples
                logger.debug(f'Audio chunk recorded. RMS: {rms:.4f}, Total: {total_recorded/SAMPLE_RATE:.0f}s')
            else:
                all_audio.append(chunk)  # Keep silence in recording for natural flow
                total_recorded += chunk_samples
                
                if recording_started:
                    if silence_start is None:
                        silence_start = time.time()
                    elif time.time() - silence_start > SILENCE_TIMEOUT_SECONDS:
                        logger.info(f'Silence detected for {SILENCE_TIMEOUT_SECONDS}s. Stopping recording.')
                        break
        
        if not all_audio:
            logger.warning('No audio captured.')
            return None
        
        audio_data = np.concatenate(all_audio)
        sf.write(str(filename), audio_data, SAMPLE_RATE)
        duration_actual = len(audio_data) / SAMPLE_RATE
        logger.info(f'Recording saved: {filename} ({duration_actual:.1f} seconds)')
        return filename
        
    except Exception as e:
        logger.error(f'Recording error: {e}')
        return None


def transcribe_audio(audio_path: Path) -> dict:
    """Send audio to Deepgram Nova-3 for transcription with speaker diarization."""
    logger.info(f'Transcribing: {audio_path}')
    
    try:
        deepgram = DeepgramClient(os.getenv('DEEPGRAM_API_KEY'))
        
        with open(audio_path, 'rb') as f:
            buffer_data = f.read()
        
        payload = {'buffer': buffer_data}
        
        options = PrerecordedOptions(
            model='nova-3',
            language='en-US',
            smart_format=True,
            punctuate=True,
            paragraphs=True,
            diarize=True,
            utterances=True,
            detect_language=True,
            keywords=[
                'CNC:2', 'PLC:2', 'OEE:2', 'TPM:1.5',
                'changeover:1.5', 'downtime:2', 'scrap rate:2',
                'first pass yield:2', 'cycle time:1.5',
                'work order:1.5', 'lot number:2', 'batch:1.5',
                'preventive maintenance:1.5', 'lockout tagout:2',
                'PPE:2', 'near miss:2', 'safety incident:2',
                'quality hold:2', 'nonconformance:2'
            ]
        )
        
        response = deepgram.listen.rest.v('1').transcribe_file(payload, options)
        result = response.to_dict()
        
        # Save raw transcript
        transcript_path = TRANSCRIPT_DIR / f'{audio_path.stem}_transcript.json'
        with open(transcript_path, 'w') as f:
            json.dump(result, f, indent=2)
        
        logger.info(f'Transcript saved: {transcript_path}')
        return result
        
    except Exception as e:
        logger.error(f'Transcription error: {e}')
        return None


def load_speaker_map() -> dict:
    """Load speaker name mapping from configuration file."""
    map_path = Path('./speaker_map.json')
    if map_path.exists():
        with open(map_path) as f:
            return json.load(f)
    return {}


def format_diarized_transcript(deepgram_result: dict) -> str:
    """Convert Deepgram diarized output to a readable speaker-labeled transcript."""
    speaker_map = load_speaker_map()
    utterances = deepgram_result.get('results', {}).get('utterances', [])
    
    lines = []
    for utt in utterances:
        speaker_id = f"Speaker {utt.get('speaker', '?')}"
        speaker_name = speaker_map.get(speaker_id, speaker_id)
        text = utt.get('transcript', '')
        start_time = utt.get('start', 0)
        minutes = int(start_time // 60)
        seconds = int(start_time % 60)
        lines.append(f'[{minutes:02d}:{seconds:02d}] {speaker_name}: {text}')
    
    return '\n'.join(lines)


def run_pipeline(duration_minutes: int = None, verbose: bool = False):
    """Execute the full capture-transcribe-summarize-deliver pipeline."""
    pipeline_start = datetime.now()
    shift = get_shift_name()
    
    logger.info(f'=== Pipeline started: {shift} shift standup ===')
    
    # Step 1: Record
    audio_path = record_meeting(duration_minutes)
    if not audio_path:
        logger.error('Recording failed. Pipeline aborted.')
        return
    
    # Step 2: Transcribe
    transcript_result = transcribe_audio(audio_path)
    if not transcript_result:
        logger.error('Transcription failed. Pipeline aborted.')
        return
    
    # Step 3: Format diarized transcript
    formatted_transcript = format_diarized_transcript(transcript_result)
    if verbose:
        print('\n--- TRANSCRIPT ---')
        print(formatted_transcript)
    
    # Step 4: Summarize into structured handoff note
    handoff_note = generate_handoff_note(
        transcript=formatted_transcript,
        shift=shift,
        meeting_date=pipeline_start.strftime('%Y-%m-%d'),
        meeting_time=pipeline_start.strftime('%H:%M')
    )
    
    if not handoff_note:
        logger.error('Summarization failed. Pipeline aborted.')
        return
    
    # Save handoff note
    handoff_path = HANDOFF_DIR / f'handoff_{shift}_{pipeline_start.strftime("%Y%m%d_%H%M%S")}.json'
    with open(handoff_path, 'w') as f:
        json.dump(handoff_note, f, indent=2)
    
    if verbose:
        print('\n--- HANDOFF NOTE ---')
        print(json.dumps(handoff_note, indent=2))
    
    # Step 5: Deliver
    try:
        post_to_teams(handoff_note)
        logger.info('Posted to Teams successfully.')
    except Exception as e:
        logger.error(f'Teams delivery failed: {e}')
    
    try:
        upload_to_sharepoint(audio_path, handoff_path, formatted_transcript)
        logger.info('Uploaded to SharePoint successfully.')
    except Exception as e:
        logger.error(f'SharePoint upload failed: {e}')
    
    elapsed = (datetime.now() - pipeline_start).total_seconds()
    logger.info(f'=== Pipeline completed in {elapsed:.1f}s ===')


def run_service():
    """Run as a persistent service, triggering at scheduled times."""
    standup_times = os.getenv('STANDUP_SCHEDULE', '06:45,14:45').split(',')
    
    for t in standup_times:
        t = t.strip()
        schedule.every().day.at(t).do(run_pipeline)
        logger.info(f'Scheduled standup capture at {t}')
    
    logger.info('Capture agent service started. Waiting for scheduled times...')
    while True:
        schedule.run_pending()
        time.sleep(30)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Manufacturing Standup Capture Agent')
    parser.add_argument('--service', action='store_true', help='Run as persistent service')
    parser.add_argument('--once', action='store_true', help='Run single capture cycle')
    parser.add_argument('--test', action='store_true', help='Run test capture (short duration)')
    parser.add_argument('--duration', type=int, default=None, help='Recording duration in seconds')
    parser.add_argument('--verbose', action='store_true', help='Print outputs to console')
    args = parser.parse_args()
    
    if args.service:
        run_service()
    elif args.test:
        run_pipeline(duration_minutes=(args.duration or 60) / 60, verbose=True)
    elif args.once:
        run_pipeline(duration_minutes=args.duration, verbose=args.verbose)
    else:
        parser.print_help()

#!/usr/bin/env python3
"""Manufacturing Shift Handoff Note Generator using GPT-5.4."""

import os
import json
import logging
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
logger = logging.getLogger(__name__)

client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

SYSTEM_PROMPT = """You are an expert manufacturing shift handoff report generator. You analyze transcribed production standup meeting discussions and produce structured shift handoff notes.

You must extract and organize information into the following categories:
1. **Production Status**: Current production rates, targets, variances, lot/batch numbers discussed
2. **Equipment Status**: Machine status, breakdowns, scheduled maintenance, changeovers
3. **Safety Issues**: Near misses, incidents, PPE concerns, lockout/tagout status, hazard observations
4. **Quality Issues**: Defects, scrap rates, holds, nonconformances, customer complaints
5. **Action Items**: Tasks assigned to specific people with deadlines
6. **Open Issues for Next Shift**: Unresolved problems the incoming shift must address
7. **Staffing Notes**: Absences, overtime, temporary workers, training needs

Rules:
- Only include information explicitly discussed in the transcript. Do NOT infer or fabricate.
- Attribute statements to the speaker who said them using the speaker labels in the transcript.
- For action items, clearly state WHO is responsible and WHAT they must do.
- Flag any safety issue with severity: 'critical' (immediate danger), 'high' (needs attention this shift), 'medium' (monitor), or 'low' (informational).
- Flag any equipment issue with severity: 'down' (not running), 'degraded' (running with issues), 'scheduled' (planned maintenance), or 'ok'.
- If production numbers are mentioned, include them with units.
- Use plain, direct language appropriate for a factory floor audience.
- Output valid JSON only. No markdown, no commentary."""

USER_PROMPT_TEMPLATE = """Analyze the following production standup meeting transcript and generate a structured shift handoff note.

Meeting Date: {meeting_date}
Meeting Time: {meeting_time}
Shift: {shift} shift

--- TRANSCRIPT START ---
{transcript}
--- TRANSCRIPT END ---

Generate the shift handoff note as a JSON object with this exact structure:
{{
  "handoff_metadata": {{
    "date": "{meeting_date}",
    "time": "{meeting_time}",
    "outgoing_shift": "{shift}",
    "incoming_shift": "<determine from context or leave as next shift>",
    "meeting_duration_minutes": <estimated from timestamps>,
    "attendees": ["list of speaker names from transcript"]
  }},
  "production_status": [
    {{
      "line_or_area": "<production line or area>",
      "status": "<running/down/changeover>",
      "current_output": "<number with units if mentioned>",
      "target_output": "<number with units if mentioned>",
      "variance": "<ahead/behind/on-target>",
      "notes": "<additional context>",
      "reported_by": "<speaker name>"
    }}
  ],
  "equipment_status": [
    {{
      "equipment_name": "<machine or system name>",
      "status": "<down/degraded/scheduled/ok>",
      "issue_description": "<what's wrong or what's planned>",
      "estimated_resolution": "<when it should be fixed if mentioned>",
      "reported_by": "<speaker name>"
    }}
  ],
  "safety_issues": [
    {{
      "description": "<what happened or was observed>",
      "severity": "<critical/high/medium/low>",
      "location": "<where in the facility>",
      "action_required": "<what needs to be done>",
      "reported_by": "<speaker name>"
    }}
  ],
  "quality_issues": [
    {{
      "description": "<defect, hold, or nonconformance details>",
      "affected_product": "<part number, lot, or product name if mentioned>",
      "action_required": "<what needs to be done>",
      "reported_by": "<speaker name>"
    }}
  ],
  "action_items": [
    {{
      "task": "<specific task description>",
      "assigned_to": "<person name>",
      "deadline": "<when it's due if mentioned, otherwise 'this shift'>",
      "priority": "<high/medium/low>",
      "context": "<why this task matters>"
    }}
  ],
  "open_issues_for_next_shift": [
    {{
      "issue": "<description of unresolved issue>",
      "context": "<background information>",
      "recommended_action": "<what the next shift should do>"
    }}
  ],
  "staffing_notes": [
    {{
      "note": "<absence, overtime, training, or staffing change>",
      "impact": "<how this affects operations>"
    }}
  ],
  "summary": "<2-3 sentence executive summary of the most important points from this standup for the incoming shift supervisor>"
}}

IMPORTANT: If a category has no relevant items from the transcript, use an empty array []. Do not omit any category. Output ONLY the JSON object."""


def generate_handoff_note(
    transcript: str,
    shift: str,
    meeting_date: str,
    meeting_time: str
) -> dict:
    """Generate a structured shift handoff note from a meeting transcript."""
    
    user_prompt = USER_PROMPT_TEMPLATE.format(
        transcript=transcript,
        shift=shift,
        meeting_date=meeting_date,
        meeting_time=meeting_time
    )
    
    try:
        response = client.chat.completions.create(
            model='gpt-5.4',
            messages=[
                {'role': 'system', 'content': SYSTEM_PROMPT},
                {'role': 'user', 'content': user_prompt}
            ],
            temperature=0.1,  # Low temperature for consistent, factual extraction
            max_tokens=4000,
            response_format={'type': 'json_object'}
        )
        
        content = response.choices[0].message.content
        handoff_note = json.loads(content)
        
        # Validate required keys
        required_keys = [
            'handoff_metadata', 'production_status', 'equipment_status',
            'safety_issues', 'quality_issues', 'action_items',
            'open_issues_for_next_shift', 'staffing_notes', 'summary'
        ]
        for key in required_keys:
            if key not in handoff_note:
                handoff_note[key] = [] if key != 'summary' and key != 'handoff_metadata' else ''
        
        logger.info(f'Handoff note generated: {len(handoff_note.get("action_items", []))} action items, '
                     f'{len(handoff_note.get("safety_issues", []))} safety issues, '
                     f'{len(handoff_note.get("equipment_status", []))} equipment items')
        
        # Log token usage for cost tracking
        usage = response.usage
        logger.info(f'Token usage - Input: {usage.prompt_tokens}, Output: {usage.completion_tokens}, '
                     f'Est. cost: ${(usage.prompt_tokens * 2.5 + usage.completion_tokens * 10) / 1_000_000:.4f}')
        
        return handoff_note
        
    except json.JSONDecodeError as e:
        logger.error(f'Failed to parse GPT-5.4 response as JSON: {e}')
        logger.error(f'Raw response: {content[:500]}')
        return None
    except Exception as e:
        logger.error(f'Summarization error: {e}')
        return None

# Teams webhook, SharePoint upload, and email notification

#!/usr/bin/env python3
"""Delivery module: Teams webhook, SharePoint upload, and email notification."""

import os
import json
import logging
from datetime import datetime
from pathlib import Path

import requests
from msal import ConfidentialClientApplication
from dotenv import load_dotenv

load_dotenv()
logger = logging.getLogger(__name__)

# Configuration
TEAMS_WEBHOOK_URL = os.getenv('TEAMS_WEBHOOK_URL')
SHAREPOINT_SITE_ID = os.getenv('SHAREPOINT_SITE_ID')
TENANT_ID = os.getenv('SHAREPOINT_TENANT_ID')
CLIENT_ID = os.getenv('SHAREPOINT_CLIENT_ID')
CLIENT_SECRET = os.getenv('SHAREPOINT_CLIENT_SECRET')
GRAPH_API_BASE = 'https://graph.microsoft.com/v1.0'


def get_graph_token() -> str:
    """Acquire Microsoft Graph API token using MSAL."""
    app = ConfidentialClientApplication(
        CLIENT_ID,
        authority=f'https://login.microsoftonline.com/{TENANT_ID}',
        client_credential=CLIENT_SECRET
    )
    result = app.acquire_token_for_client(scopes=['https://graph.microsoft.com/.default'])
    if 'access_token' in result:
        return result['access_token']
    raise Exception(f'Failed to acquire Graph token: {result.get("error_description", "Unknown error")}')


def build_adaptive_card(handoff_note: dict) -> dict:
    """Build a Teams Adaptive Card from the structured handoff note."""
    metadata = handoff_note.get('handoff_metadata', {})
    summary = handoff_note.get('summary', 'No summary available.')
    safety_issues = handoff_note.get('safety_issues', [])
    equipment_status = handoff_note.get('equipment_status', [])
    action_items = handoff_note.get('action_items', [])
    production_status = handoff_note.get('production_status', [])
    open_issues = handoff_note.get('open_issues_for_next_shift', [])
    
    # Build safety section with color coding
    safety_facts = []
    for issue in safety_issues:
        severity_emoji = {'critical': '🔴', 'high': '🟠', 'medium': '🟡', 'low': '🟢'}.get(issue.get('severity', ''), '⚪')
        safety_facts.append({
            'type': 'TextBlock',
            'text': f"{severity_emoji} **{issue.get('severity', 'unknown').upper()}**: {issue.get('description', '')} — *{issue.get('action_required', '')}*",
            'wrap': True,
            'size': 'Small'
        })
    
    # Build equipment section
    equipment_facts = []
    for eq in equipment_status:
        status_emoji = {'down': '🔴', 'degraded': '🟠', 'scheduled': '🔵', 'ok': '🟢'}.get(eq.get('status', ''), '⚪')
        equipment_facts.append({
            'type': 'TextBlock',
            'text': f"{status_emoji} **{eq.get('equipment_name', '')}**: {eq.get('issue_description', 'No issues')} (ETA: {eq.get('estimated_resolution', 'N/A')})",
            'wrap': True,
            'size': 'Small'
        })
    
    # Build action items section
    action_facts = []
    for item in action_items:
        priority_emoji = {'high': '🔴', 'medium': '🟡', 'low': '🟢'}.get(item.get('priority', ''), '⚪')
        action_facts.append({
            'type': 'TextBlock',
            'text': f"{priority_emoji} **{item.get('assigned_to', 'Unassigned')}**: {item.get('task', '')} (Due: {item.get('deadline', 'TBD')})",
            'wrap': True,
            'size': 'Small'
        })
    
    card = {
        'type': 'message',
        'attachments': [{
            'contentType': 'application/vnd.microsoft.card.adaptive',
            'contentUrl': None,
            'content': {
                '$schema': 'http://adaptivecards.io/schemas/adaptive-card.json',
                'type': 'AdaptiveCard',
                'version': '1.4',
                'body': [
                    {
                        'type': 'TextBlock',
                        'text': f"🏭 Shift Handoff: {metadata.get('outgoing_shift', '').title()} → {metadata.get('incoming_shift', 'Next')} Shift",
                        'weight': 'Bolder',
                        'size': 'Large',
                        'wrap': True
                    },
                    {
                        'type': 'TextBlock',
                        'text': f"📅 {metadata.get('date', '')} at {metadata.get('time', '')} | Attendees: {', '.join(metadata.get('attendees', []))}",
                        'size': 'Small',
                        'isSubtle': True,
                        'wrap': True
                    },
                    {
                        'type': 'TextBlock',
                        'text': f"**Summary:** {summary}",
                        'wrap': True,
                        'separator': True
                    },
                    {
                        'type': 'TextBlock',
                        'text': '⚠️ **Safety Issues**' if safety_facts else '✅ **No Safety Issues Reported**',
                        'weight': 'Bolder',
                        'separator': True
                    },
                    *safety_facts,
                    {
                        'type': 'TextBlock',
                        'text': '🔧 **Equipment Status**',
                        'weight': 'Bolder',
                        'separator': True
                    },
                    *(equipment_facts if equipment_facts else [{'type': 'TextBlock', 'text': 'All equipment running normally.', 'size': 'Small'}]),
                    {
                        'type': 'TextBlock',
                        'text': '📋 **Action Items**',
                        'weight': 'Bolder',
                        'separator': True
                    },
                    *(action_facts if action_facts else [{'type': 'TextBlock', 'text': 'No action items assigned.', 'size': 'Small'}]),
                    {
                        'type': 'TextBlock',
                        'text': f"📌 **Open Issues for Next Shift:** {len(open_issues)} item(s)",
                        'weight': 'Bolder',
                        'separator': True
                    },
                    *[{'type': 'TextBlock', 'text': f"• {oi.get('issue', '')} — *{oi.get('recommended_action', '')}*", 'wrap': True, 'size': 'Small'} for oi in open_issues]
                ]
            }
        }]
    }
    return card


def post_to_teams(handoff_note: dict):
    """Post the handoff note as an Adaptive Card to Teams via incoming webhook."""
    if not TEAMS_WEBHOOK_URL:
        logger.warning('TEAMS_WEBHOOK_URL not configured. Skipping Teams delivery.')
        return
    
    card = build_adaptive_card(handoff_note)
    
    response = requests.post(
        TEAMS_WEBHOOK_URL,
        json=card,
        headers={'Content-Type': 'application/json'},
        timeout=30
    )
    
    if response.status_code in (200, 202):
        logger.info('Handoff note posted to Teams successfully.')
    else:
        logger.error(f'Teams webhook failed: {response.status_code} - {response.text}')
        raise Exception(f'Teams webhook returned {response.status_code}')


def upload_to_sharepoint(audio_path: Path, handoff_path: Path, transcript_text: str):
    """Upload audio, handoff note, and transcript to SharePoint document libraries."""
    if not all([SHAREPOINT_SITE_ID, TENANT_ID, CLIENT_ID, CLIENT_SECRET]):
        logger.warning('SharePoint credentials not fully configured. Skipping upload.')
        return
    
    token = get_graph_token()
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/octet-stream'
    }
    
    date_folder = datetime.now().strftime('%Y/%m')
    
    # Upload audio file
    if audio_path and audio_path.exists():
        audio_url = f"{GRAPH_API_BASE}/sites/{SHAREPOINT_SITE_ID}/drive/root:/Audio-Archive/{date_folder}/{audio_path.name}:/content"
        with open(audio_path, 'rb') as f:
            resp = requests.put(audio_url, headers=headers, data=f, timeout=120)
        if resp.status_code in (200, 201):
            logger.info(f'Audio uploaded to SharePoint: {audio_path.name}')
        else:
            logger.error(f'Audio upload failed: {resp.status_code} - {resp.text[:200]}')
    
    # Upload handoff note JSON
    if handoff_path and handoff_path.exists():
        note_url = f"{GRAPH_API_BASE}/sites/{SHAREPOINT_SITE_ID}/drive/root:/Handoff-Notes/{date_folder}/{handoff_path.name}:/content"
        with open(handoff_path, 'rb') as f:
            resp = requests.put(note_url, headers=headers, data=f, timeout=30)
        if resp.status_code in (200, 201):
            logger.info(f'Handoff note uploaded to SharePoint: {handoff_path.name}')
        else:
            logger.error(f'Handoff note upload failed: {resp.status_code} - {resp.text[:200]}')
    
    # Upload transcript as text file
    if transcript_text:
        transcript_filename = f"{handoff_path.stem.replace('handoff_', 'transcript_')}.txt"
        transcript_url = f"{GRAPH_API_BASE}/sites/{SHAREPOINT_SITE_ID}/drive/root:/Raw-Transcripts/{date_folder}/{transcript_filename}:/content"
        headers_text = {**headers, 'Content-Type': 'text/plain'}
        resp = requests.put(transcript_url, headers=headers_text, data=transcript_text.encode('utf-8'), timeout=30)
        if resp.status_code in (200, 201):
            logger.info(f'Transcript uploaded to SharePoint: {transcript_filename}')
        else:
            logger.error(f'Transcript upload failed: {resp.status_code} - {resp.text[:200]}')


if __name__ == '__main__':
    # Test with a sample handoff note
    sample_note = {
        'handoff_metadata': {
            'date': '2025-01-15',
            'time': '06:50',
            'outgoing_shift': 'night',
            'incoming_shift': 'day',
            'meeting_duration_minutes': 14,
            'attendees': ['Mike R.', 'Sarah L.', 'Tom K.']
        },
        'summary': 'Night shift completed 450 of 500 target units on Line 1. CNC-04 is down awaiting a spindle bearing replacement. Near miss reported in packaging area — forklift clearance issue being addressed.',
        'safety_issues': [{'description': 'Forklift near miss in packaging', 'severity': 'high', 'location': 'Packaging Area B', 'action_required': 'Add floor markings for pedestrian path', 'reported_by': 'Sarah L.'}],
        'equipment_status': [{'equipment_name': 'CNC-04', 'status': 'down', 'issue_description': 'Spindle bearing failure', 'estimated_resolution': 'Noon today — parts on order', 'reported_by': 'Tom K.'}],
        'action_items': [{'task': 'Call bearing supplier to confirm delivery ETA', 'assigned_to': 'Tom K.', 'deadline': '8:00 AM', 'priority': 'high', 'context': 'CNC-04 down'}],
        'production_status': [{'line_or_area': 'Line 1', 'status': 'running', 'current_output': '450 units', 'target_output': '500 units', 'variance': 'behind', 'notes': '10% behind due to CNC-04 downtime', 'reported_by': 'Mike R.'}],
        'quality_issues': [],
        'open_issues_for_next_shift': [{'issue': 'CNC-04 spindle bearing replacement pending', 'context': 'Parts ordered, ETA noon', 'recommended_action': 'Redirect CNC-04 jobs to CNC-02 until repair complete'}],
        'staffing_notes': []
    }
    post_to_teams(sample_note)
    print('Test card posted to Teams.')

SYSTEM PROMPT:
You are a manufacturing operations analyst. You analyze a week's worth of shift handoff notes and produce a concise weekly production summary for plant management.

Focus on:
1. Overall production performance vs. targets (calculate weekly totals and variances)
2. Recurring equipment issues (identify patterns across the week)
3. Safety trend analysis (are incidents increasing or decreasing?)
4. Quality metrics summary
5. Key accomplishments
6. Recommendations for next week

Format the output as a clear, professional report suitable for a plant manager. Use bullet points, not paragraphs. Include specific numbers where available.

USER PROMPT TEMPLATE (Power Automate dynamic content in curly braces):
Analyze the following shift handoff notes from the week of {WeekStartDate} to {WeekEndDate}:

{ConcatenatedHandoffNotes}

Produce a weekly production summary report.

{
  "model": "gpt-5.4",
  "messages": [
    {"role": "system", "content": "<system prompt above>"},
    {"role": "user", "content": "<user prompt with dynamic content>"}
  ],
  "temperature": 0.2,
  "max_tokens": 3000
}

{
  "title": "[Auto] @{items('Apply_to_each')?['equipment_name']} - @{items('Apply_to_each')?['status']}",
  "description": "Reported during @{body('Parse_JSON')?['handoff_metadata']?['outgoing_shift']} shift standup on @{body('Parse_JSON')?['handoff_metadata']?['date']}\n\nIssue: @{items('Apply_to_each')?['issue_description']}\nReported by: @{items('Apply_to_each')?['reported_by']}\nEstimated Resolution: @{items('Apply_to_each')?['estimated_resolution']}",
  "priority": 1,
  "category": "Breakdown",
  "dueDate": "@{addDays(utcNow(), 1)}"
}

pip install --upgrade -r requirements.txt