smed-analyzer

What this skill does

# smed-analyzer

You are **smed-analyzer** - a specialized skill for analyzing and reducing changeover times using the Single Minute Exchange of Die (SMED) methodology.

## Overview

This skill enables AI-powered SMED analysis including:
- Changeover video analysis
- Internal vs external activity separation
- Activity timing and sequencing
- Conversion opportunity identification
- Parallel work assignment
- Quick-release mechanism suggestions
- Before/after comparison reports
- Standard changeover documentation

## Prerequisites

- Video recording capability
- Stopwatch or timing software
- Understanding of changeover process

## Capabilities

### 1. Changeover Activity Recording

```python
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional
import datetime

class ActivityType(Enum):
    INTERNAL = "internal"  # Machine must be stopped
    EXTERNAL = "external"  # Can be done while running

@dataclass
class ChangeoverActivity:
    id: int
    description: str
    start_time: float  # seconds from changeover start
    end_time: float
    activity_type: ActivityType
    operator: str
    tools_required: List[str]
    notes: Optional[str] = None

    @property
    def duration(self):
        return self.end_time - self.start_time

class ChangeoverAnalysis:
    """
    Record and analyze changeover activities
    """
    def __init__(self, machine_name: str, from_product: str, to_product: str):
        self.machine_name = machine_name
        self.from_product = from_product
        self.to_product = to_product
        self.activities: List[ChangeoverActivity] = []
        self.timestamp = datetime.datetime.now()

    def add_activity(self, description, start, end, activity_type,
                    operator, tools=None, notes=None):
        activity = ChangeoverActivity(
            id=len(self.activities) + 1,
            description=description,
            start_time=start,
            end_time=end,
            activity_type=activity_type,
            operator=operator,
            tools_required=tools or [],
            notes=notes
        )
        self.activities.append(activity)
        return activity

    def summary(self):
        internal = [a for a in self.activities if a.activity_type == ActivityType.INTERNAL]
        external = [a for a in self.activities if a.activity_type == ActivityType.EXTERNAL]

        return {
            "total_changeover_time": max(a.end_time for a in self.activities),
            "internal_time": sum(a.duration for a in internal),
            "external_time": sum(a.duration for a in external),
            "num_activities": len(self.activities),
            "num_internal": len(internal),
            "num_external": len(external)
        }
```

### 2. Internal/External Separation Analysis

```python
def analyze_internal_external(activities):
    """
    Identify activities that could be converted from internal to external
    """
    conversion_opportunities = []

    for activity in activities:
        if activity.activity_type == ActivityType.INTERNAL:
            # Check for conversion potential
            potential = assess_conversion_potential(activity)
            if potential['can_convert']:
                conversion_opportunities.append({
                    "activity_id": activity.id,
                    "description": activity.description,
                    "current_duration": activity.duration,
                    "conversion_method": potential['method'],
                    "estimated_savings": potential['savings'],
                    "investment_required": potential['investment']
                })

    return conversion_opportunities

def assess_conversion_potential(activity):
    """
    Assess if internal activity can become external
    """
    # Keywords indicating conversion potential
    prep_keywords = ['get', 'find', 'look for', 'search', 'locate', 'bring']
    adjustment_keywords = ['adjust', 'set', 'calibrate', 'tune']
    removal_keywords = ['remove', 'take off', 'disconnect']

    desc_lower = activity.description.lower()

    # Preparation activities can often be done externally
    if any(kw in desc_lower for kw in prep_keywords):
        return {
            'can_convert': True,
            'method': 'Pre-stage tools and materials before stopping machine',
            'savings': activity.duration * 0.9,  # 90% reduction
            'investment': 'Low - organization and staging area'
        }

    # Adjustments might be eliminated with presetting
    if any(kw in desc_lower for kw in adjustment_keywords):
        return {
            'can_convert': True,
            'method': 'Use preset tooling or jigs for instant settings',
            'savings': activity.duration * 0.7,
            'investment': 'Medium - preset tooling investment'
        }

    return {'can_convert': False}
```

### 3. Parallel Work Analysis

```python
def analyze_parallel_opportunities(activities, available_operators):
    """
    Identify activities that can be done in parallel
    """
    # Group activities by time window
    timeline = []

    for activity in activities:
        timeline.append({
            'time': activity.start_time,
            'type': 'start',
            'activity': activity
        })
        timeline.append({
            'time': activity.end_time,
            'type': 'end',
            'activity': activity
        })

    timeline.sort(key=lambda x: x['time'])

    # Analyze operator utilization
    parallel_opportunities = []
    current_activities = []

    for event in timeline:
        if event['type'] == 'start':
            current_activities.append(event['activity'])
        else:
            current_activities.remove(event['activity'])

        # Check if operators are idle
        active_operators = len(set(a.operator for a in current_activities))
        idle_operators = available_operators - active_operators

        if idle_operators > 0 and len(current_activities) > 0:
            parallel_opportunities.append({
                'time': event['time'],
                'idle_operators': idle_operators,
                'active_activities': [a.description for a in current_activities]
            })

    return parallel_opportunities

def optimize_parallel_work(activities, available_operators):
    """
    Reassign activities for parallel execution
    """
    # Simple greedy assignment
    assignments = {i: [] for i in range(available_operators)}
    operator_end_times = [0] * available_operators

    # Sort by start time
    sorted_activities = sorted(activities, key=lambda a: a.start_time)

    for activity in sorted_activities:
        # Find operator who finishes earliest
        earliest_op = min(range(available_operators),
                         key=lambda i: operator_end_times[i])

        # Assign to this operator
        new_start = max(activity.start_time, operator_end_times[earliest_op])
        new_end = new_start + activity.duration

        assignments[earliest_op].append({
            'activity': activity.description,
            'original_start': activity.start_time,
            'new_start': new_start,
            'end': new_end
        })

        operator_end_times[earliest_op] = new_end

    new_total_time = max(operator_end_times)
    original_total_time = max(a.end_time for a in activities)

    return {
        'assignments': assignments,
        'original_time': original_total_time,
        'optimized_time': new_total_time,
        'time_savings': original_total_time - new_total_time,
        'reduction_percent': (1 - new_total_time/original_total_time) * 100
    }
```

### 4. Quick-Release Mechanism Suggestions

```python
def suggest_quick_release_mechanisms(activities):
    """
    Suggest engineering improvements for faster changeovers
    """
    suggestions = []

    for activity in activities:
        desc_lower = activity.description.lower()

        # Fastener improvements
        if any(word in desc_