port-nuker 1.0.1 → 1.0.3

package/.agent/skills/skills/app-store-optimization/launch_checklist.py

@@ -1,739 +0,0 @@
-"""
-Launch checklist module for App Store Optimization.
-Generates comprehensive pre-launch and update checklists.
-"""
-
-from typing import Dict, List, Any, Optional
-from datetime import datetime, timedelta
-
-
-class LaunchChecklistGenerator:
-    """Generates comprehensive checklists for app launches and updates."""
-
-    def __init__(self, platform: str = 'both'):
-        """
-        Initialize checklist generator.
-
-        Args:
-            platform: 'apple', 'google', or 'both'
-        """
-        if platform not in ['apple', 'google', 'both']:
-            raise ValueError("Platform must be 'apple', 'google', or 'both'")
-
-        self.platform = platform
-
-    def generate_prelaunch_checklist(
-        self,
-        app_info: Dict[str, Any],
-        launch_date: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Generate comprehensive pre-launch checklist.
-
-        Args:
-            app_info: App information (name, category, target_audience)
-            launch_date: Target launch date (YYYY-MM-DD)
-
-        Returns:
-            Complete pre-launch checklist
-        """
-        checklist = {
-            'app_info': app_info,
-            'launch_date': launch_date,
-            'checklists': {}
-        }
-
-        # Generate platform-specific checklists
-        if self.platform in ['apple', 'both']:
-            checklist['checklists']['apple'] = self._generate_apple_checklist(app_info)
-
-        if self.platform in ['google', 'both']:
-            checklist['checklists']['google'] = self._generate_google_checklist(app_info)
-
-        # Add universal checklist items
-        checklist['checklists']['universal'] = self._generate_universal_checklist(app_info)
-
-        # Generate timeline
-        if launch_date:
-            checklist['timeline'] = self._generate_launch_timeline(launch_date)
-
-        # Calculate completion status
-        checklist['summary'] = self._calculate_checklist_summary(checklist['checklists'])
-
-        return checklist
-
-    def validate_app_store_compliance(
-        self,
-        app_data: Dict[str, Any],
-        platform: str = 'apple'
-    ) -> Dict[str, Any]:
-        """
-        Validate compliance with app store guidelines.
-
-        Args:
-            app_data: App data including metadata, privacy policy, etc.
-            platform: 'apple' or 'google'
-
-        Returns:
-            Compliance validation report
-        """
-        validation_results = {
-            'platform': platform,
-            'is_compliant': True,
-            'errors': [],
-            'warnings': [],
-            'recommendations': []
-        }
-
-        if platform == 'apple':
-            self._validate_apple_compliance(app_data, validation_results)
-        elif platform == 'google':
-            self._validate_google_compliance(app_data, validation_results)
-
-        # Determine overall compliance
-        validation_results['is_compliant'] = len(validation_results['errors']) == 0
-
-        return validation_results
-
-    def create_update_plan(
-        self,
-        current_version: str,
-        planned_features: List[str],
-        update_frequency: str = 'monthly'
-    ) -> Dict[str, Any]:
-        """
-        Create update cadence and feature rollout plan.
-
-        Args:
-            current_version: Current app version
-            planned_features: List of planned features
-            update_frequency: 'weekly', 'biweekly', 'monthly', 'quarterly'
-
-        Returns:
-            Update plan with cadence and feature schedule
-        """
-        # Calculate next versions
-        next_versions = self._calculate_next_versions(
-            current_version,
-            update_frequency,
-            len(planned_features)
-        )
-
-        # Distribute features across versions
-        feature_schedule = self._distribute_features(
-            planned_features,
-            next_versions
-        )
-
-        # Generate "What's New" templates
-        whats_new_templates = [
-            self._generate_whats_new_template(version_data)
-            for version_data in feature_schedule
-        ]
-
-        return {
-            'current_version': current_version,
-            'update_frequency': update_frequency,
-            'planned_updates': len(feature_schedule),
-            'feature_schedule': feature_schedule,
-            'whats_new_templates': whats_new_templates,
-            'recommendations': self._generate_update_recommendations(update_frequency)
-        }
-
-    def optimize_launch_timing(
-        self,
-        app_category: str,
-        target_audience: str,
-        current_date: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Recommend optimal launch timing.
-
-        Args:
-            app_category: App category
-            target_audience: Target audience description
-            current_date: Current date (YYYY-MM-DD), defaults to today
-
-        Returns:
-            Launch timing recommendations
-        """
-        if not current_date:
-            current_date = datetime.now().strftime('%Y-%m-%d')
-
-        # Analyze launch timing factors
-        day_of_week_rec = self._recommend_day_of_week(app_category)
-        seasonal_rec = self._recommend_seasonal_timing(app_category, current_date)
-        competitive_rec = self._analyze_competitive_timing(app_category)
-
-        # Calculate optimal dates
-        optimal_dates = self._calculate_optimal_dates(
-            current_date,
-            day_of_week_rec,
-            seasonal_rec
-        )
-
-        return {
-            'current_date': current_date,
-            'optimal_launch_dates': optimal_dates,
-            'day_of_week_recommendation': day_of_week_rec,
-            'seasonal_considerations': seasonal_rec,
-            'competitive_timing': competitive_rec,
-            'final_recommendation': self._generate_timing_recommendation(
-                optimal_dates,
-                seasonal_rec
-            )
-        }
-
-    def plan_seasonal_campaigns(
-        self,
-        app_category: str,
-        current_month: int = None
-    ) -> Dict[str, Any]:
-        """
-        Identify seasonal opportunities for ASO campaigns.
-
-        Args:
-            app_category: App category
-            current_month: Current month (1-12), defaults to current
-
-        Returns:
-            Seasonal campaign opportunities
-        """
-        if not current_month:
-            current_month = datetime.now().month
-
-        # Identify relevant seasonal events
-        seasonal_opportunities = self._identify_seasonal_opportunities(
-            app_category,
-            current_month
-        )
-
-        # Generate campaign ideas
-        campaigns = [
-            self._generate_seasonal_campaign(opportunity)
-            for opportunity in seasonal_opportunities
-        ]
-
-        return {
-            'current_month': current_month,
-            'category': app_category,
-            'seasonal_opportunities': seasonal_opportunities,
-            'campaign_ideas': campaigns,
-            'implementation_timeline': self._create_seasonal_timeline(campaigns)
-        }
-
-    def _generate_apple_checklist(self, app_info: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Generate Apple App Store specific checklist."""
-        return [
-            {
-                'category': 'App Store Connect Setup',
-                'items': [
-                    {'task': 'App Store Connect account created', 'status': 'pending'},
-                    {'task': 'App bundle ID registered', 'status': 'pending'},
-                    {'task': 'App Privacy declarations completed', 'status': 'pending'},
-                    {'task': 'Age rating questionnaire completed', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Metadata (Apple)',
-                'items': [
-                    {'task': 'App title (30 chars max)', 'status': 'pending'},
-                    {'task': 'Subtitle (30 chars max)', 'status': 'pending'},
-                    {'task': 'Promotional text (170 chars max)', 'status': 'pending'},
-                    {'task': 'Description (4000 chars max)', 'status': 'pending'},
-                    {'task': 'Keywords (100 chars, comma-separated)', 'status': 'pending'},
-                    {'task': 'Category selection (primary + secondary)', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Visual Assets (Apple)',
-                'items': [
-                    {'task': 'App icon (1024x1024px)', 'status': 'pending'},
-                    {'task': 'Screenshots (iPhone 6.7" required)', 'status': 'pending'},
-                    {'task': 'Screenshots (iPhone 5.5" required)', 'status': 'pending'},
-                    {'task': 'Screenshots (iPad Pro 12.9" if iPad app)', 'status': 'pending'},
-                    {'task': 'App preview video (optional but recommended)', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Technical Requirements (Apple)',
-                'items': [
-                    {'task': 'Build uploaded to App Store Connect', 'status': 'pending'},
-                    {'task': 'TestFlight testing completed', 'status': 'pending'},
-                    {'task': 'App tested on required iOS versions', 'status': 'pending'},
-                    {'task': 'Crash-free rate > 99%', 'status': 'pending'},
-                    {'task': 'All links in app/metadata working', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Legal & Privacy (Apple)',
-                'items': [
-                    {'task': 'Privacy Policy URL provided', 'status': 'pending'},
-                    {'task': 'Terms of Service URL (if applicable)', 'status': 'pending'},
-                    {'task': 'Data collection declarations accurate', 'status': 'pending'},
-                    {'task': 'Third-party SDKs disclosed', 'status': 'pending'}
-                ]
-            }
-        ]
-
-    def _generate_google_checklist(self, app_info: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Generate Google Play Store specific checklist."""
-        return [
-            {
-                'category': 'Play Console Setup',
-                'items': [
-                    {'task': 'Google Play Console account created', 'status': 'pending'},
-                    {'task': 'Developer profile completed', 'status': 'pending'},
-                    {'task': 'Payment merchant account linked (if paid app)', 'status': 'pending'},
-                    {'task': 'Content rating questionnaire completed', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Metadata (Google)',
-                'items': [
-                    {'task': 'App title (50 chars max)', 'status': 'pending'},
-                    {'task': 'Short description (80 chars max)', 'status': 'pending'},
-                    {'task': 'Full description (4000 chars max)', 'status': 'pending'},
-                    {'task': 'Category selection', 'status': 'pending'},
-                    {'task': 'Tags (up to 5)', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Visual Assets (Google)',
-                'items': [
-                    {'task': 'App icon (512x512px)', 'status': 'pending'},
-                    {'task': 'Feature graphic (1024x500px)', 'status': 'pending'},
-                    {'task': 'Screenshots (2-8 required, phone)', 'status': 'pending'},
-                    {'task': 'Screenshots (tablet, if applicable)', 'status': 'pending'},
-                    {'task': 'Promo video (YouTube link, optional)', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Technical Requirements (Google)',
-                'items': [
-                    {'task': 'APK/AAB uploaded to Play Console', 'status': 'pending'},
-                    {'task': 'Internal testing completed', 'status': 'pending'},
-                    {'task': 'App tested on required Android versions', 'status': 'pending'},
-                    {'task': 'Target API level meets requirements', 'status': 'pending'},
-                    {'task': 'All permissions justified', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Legal & Privacy (Google)',
-                'items': [
-                    {'task': 'Privacy Policy URL provided', 'status': 'pending'},
-                    {'task': 'Data safety section completed', 'status': 'pending'},
-                    {'task': 'Ads disclosure (if applicable)', 'status': 'pending'},
-                    {'task': 'In-app purchase disclosure (if applicable)', 'status': 'pending'}
-                ]
-            }
-        ]
-
-    def _generate_universal_checklist(self, app_info: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Generate universal (both platforms) checklist."""
-        return [
-            {
-                'category': 'Pre-Launch Marketing',
-                'items': [
-                    {'task': 'Landing page created', 'status': 'pending'},
-                    {'task': 'Social media accounts setup', 'status': 'pending'},
-                    {'task': 'Press kit prepared', 'status': 'pending'},
-                    {'task': 'Beta tester feedback collected', 'status': 'pending'},
-                    {'task': 'Launch announcement drafted', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'ASO Preparation',
-                'items': [
-                    {'task': 'Keyword research completed', 'status': 'pending'},
-                    {'task': 'Competitor analysis done', 'status': 'pending'},
-                    {'task': 'A/B test plan created for post-launch', 'status': 'pending'},
-                    {'task': 'Analytics tracking configured', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Quality Assurance',
-                'items': [
-                    {'task': 'All core features tested', 'status': 'pending'},
-                    {'task': 'User flows validated', 'status': 'pending'},
-                    {'task': 'Performance testing completed', 'status': 'pending'},
-                    {'task': 'Accessibility features tested', 'status': 'pending'},
-                    {'task': 'Security audit completed', 'status': 'pending'}
-                ]
-            },
-            {
-                'category': 'Support Infrastructure',
-                'items': [
-                    {'task': 'Support email/system setup', 'status': 'pending'},
-                    {'task': 'FAQ page created', 'status': 'pending'},
-                    {'task': 'Documentation for users prepared', 'status': 'pending'},
-                    {'task': 'Team trained on handling reviews', 'status': 'pending'}
-                ]
-            }
-        ]
-
-    def _generate_launch_timeline(self, launch_date: str) -> List[Dict[str, Any]]:
-        """Generate timeline with milestones leading to launch."""
-        launch_dt = datetime.strptime(launch_date, '%Y-%m-%d')
-
-        milestones = [
-            {
-                'date': (launch_dt - timedelta(days=90)).strftime('%Y-%m-%d'),
-                'milestone': '90 days before: Complete keyword research and competitor analysis'
-            },
-            {
-                'date': (launch_dt - timedelta(days=60)).strftime('%Y-%m-%d'),
-                'milestone': '60 days before: Finalize metadata and visual assets'
-            },
-            {
-                'date': (launch_dt - timedelta(days=45)).strftime('%Y-%m-%d'),
-                'milestone': '45 days before: Begin beta testing program'
-            },
-            {
-                'date': (launch_dt - timedelta(days=30)).strftime('%Y-%m-%d'),
-                'milestone': '30 days before: Submit app for review (Apple typically takes 1-2 days, Google instant)'
-            },
-            {
-                'date': (launch_dt - timedelta(days=14)).strftime('%Y-%m-%d'),
-                'milestone': '14 days before: Prepare launch marketing materials'
-            },
-            {
-                'date': (launch_dt - timedelta(days=7)).strftime('%Y-%m-%d'),
-                'milestone': '7 days before: Set up analytics and monitoring'
-            },
-            {
-                'date': launch_dt.strftime('%Y-%m-%d'),
-                'milestone': 'Launch Day: Release app and execute marketing plan'
-            },
-            {
-                'date': (launch_dt + timedelta(days=7)).strftime('%Y-%m-%d'),
-                'milestone': '7 days after: Monitor metrics, respond to reviews, address critical issues'
-            },
-            {
-                'date': (launch_dt + timedelta(days=30)).strftime('%Y-%m-%d'),
-                'milestone': '30 days after: Analyze launch metrics, plan first update'
-            }
-        ]
-
-        return milestones
-
-    def _calculate_checklist_summary(self, checklists: Dict[str, List[Dict[str, Any]]]) -> Dict[str, Any]:
-        """Calculate completion summary."""
-        total_items = 0
-        completed_items = 0
-
-        for platform, categories in checklists.items():
-            for category in categories:
-                for item in category['items']:
-                    total_items += 1
-                    if item['status'] == 'completed':
-                        completed_items += 1
-
-        completion_percentage = (completed_items / total_items * 100) if total_items > 0 else 0
-
-        return {
-            'total_items': total_items,
-            'completed_items': completed_items,
-            'pending_items': total_items - completed_items,
-            'completion_percentage': round(completion_percentage, 1),
-            'is_ready_to_launch': completion_percentage == 100
-        }
-
-    def _validate_apple_compliance(
-        self,
-        app_data: Dict[str, Any],
-        validation_results: Dict[str, Any]
-    ) -> None:
-        """Validate Apple App Store compliance."""
-        # Check for required fields
-        if not app_data.get('privacy_policy_url'):
-            validation_results['errors'].append("Privacy Policy URL is required")
-
-        if not app_data.get('app_icon'):
-            validation_results['errors'].append("App icon (1024x1024px) is required")
-
-        # Check metadata character limits
-        title = app_data.get('title', '')
-        if len(title) > 30:
-            validation_results['errors'].append(f"Title exceeds 30 characters ({len(title)})")
-
-        # Warnings for best practices
-        subtitle = app_data.get('subtitle', '')
-        if not subtitle:
-            validation_results['warnings'].append("Subtitle is empty - consider adding for better discoverability")
-
-        keywords = app_data.get('keywords', '')
-        if len(keywords) < 80:
-            validation_results['warnings'].append(
-                f"Keywords field underutilized ({len(keywords)}/100 chars) - add more keywords"
-            )
-
-    def _validate_google_compliance(
-        self,
-        app_data: Dict[str, Any],
-        validation_results: Dict[str, Any]
-    ) -> None:
-        """Validate Google Play Store compliance."""
-        # Check for required fields
-        if not app_data.get('privacy_policy_url'):
-            validation_results['errors'].append("Privacy Policy URL is required")
-
-        if not app_data.get('feature_graphic'):
-            validation_results['errors'].append("Feature graphic (1024x500px) is required")
-
-        # Check metadata character limits
-        title = app_data.get('title', '')
-        if len(title) > 50:
-            validation_results['errors'].append(f"Title exceeds 50 characters ({len(title)})")
-
-        short_desc = app_data.get('short_description', '')
-        if len(short_desc) > 80:
-            validation_results['errors'].append(f"Short description exceeds 80 characters ({len(short_desc)})")
-
-        # Warnings
-        if not short_desc:
-            validation_results['warnings'].append("Short description is empty")
-
-    def _calculate_next_versions(
-        self,
-        current_version: str,
-        update_frequency: str,
-        feature_count: int
-    ) -> List[str]:
-        """Calculate next version numbers."""
-        # Parse current version (assume semantic versioning)
-        parts = current_version.split('.')
-        major, minor, patch = int(parts[0]), int(parts[1]), int(parts[2] if len(parts) > 2 else 0)
-
-        versions = []
-        for i in range(feature_count):
-            if update_frequency == 'weekly':
-                patch += 1
-            elif update_frequency == 'biweekly':
-                patch += 1
-            elif update_frequency == 'monthly':
-                minor += 1
-                patch = 0
-            else:  # quarterly
-                minor += 1
-                patch = 0
-
-            versions.append(f"{major}.{minor}.{patch}")
-
-        return versions
-
-    def _distribute_features(
-        self,
-        features: List[str],
-        versions: List[str]
-    ) -> List[Dict[str, Any]]:
-        """Distribute features across versions."""
-        features_per_version = max(1, len(features) // len(versions))
-
-        schedule = []
-        for i, version in enumerate(versions):
-            start_idx = i * features_per_version
-            end_idx = start_idx + features_per_version if i < len(versions) - 1 else len(features)
-
-            schedule.append({
-                'version': version,
-                'features': features[start_idx:end_idx],
-                'release_priority': 'high' if i == 0 else ('medium' if i < len(versions) // 2 else 'low')
-            })
-
-        return schedule
-
-    def _generate_whats_new_template(self, version_data: Dict[str, Any]) -> Dict[str, str]:
-        """Generate What's New template for version."""
-        features_list = '\n'.join([f"• {feature}" for feature in version_data['features']])
-
-        template = f"""Version {version_data['version']}
-
-{features_list}
-
-We're constantly improving your experience. Thanks for using [App Name]!
-
-Have feedback? Contact us at support@[company].com"""
-
-        return {
-            'version': version_data['version'],
-            'template': template
-        }
-
-    def _generate_update_recommendations(self, update_frequency: str) -> List[str]:
-        """Generate recommendations for update strategy."""
-        recommendations = []
-
-        if update_frequency == 'weekly':
-            recommendations.append("Weekly updates show active development but ensure quality doesn't suffer")
-        elif update_frequency == 'monthly':
-            recommendations.append("Monthly updates are optimal for most apps - balance features and stability")
-
-        recommendations.extend([
-            "Include bug fixes in every update",
-            "Update 'What's New' section with each release",
-            "Respond to reviews mentioning fixed issues"
-        ])
-
-        return recommendations
-
-    def _recommend_day_of_week(self, app_category: str) -> Dict[str, Any]:
-        """Recommend best day of week to launch."""
-        # General recommendations based on category
-        if app_category.lower() in ['games', 'entertainment']:
-            return {
-                'recommended_day': 'Thursday',
-                'rationale': 'People download entertainment apps before weekend'
-            }
-        elif app_category.lower() in ['productivity', 'business']:
-            return {
-                'recommended_day': 'Tuesday',
-                'rationale': 'Business users most active mid-week'
-            }
-        else:
-            return {
-                'recommended_day': 'Wednesday',
-                'rationale': 'Mid-week provides good balance and review potential'
-            }
-
-    def _recommend_seasonal_timing(self, app_category: str, current_date: str) -> Dict[str, Any]:
-        """Recommend seasonal timing considerations."""
-        current_dt = datetime.strptime(current_date, '%Y-%m-%d')
-        month = current_dt.month
-
-        # Avoid certain periods
-        avoid_periods = []
-        if month == 12:
-            avoid_periods.append("Late December - low user engagement during holidays")
-        if month in [7, 8]:
-            avoid_periods.append("Summer months - some categories see lower engagement")
-
-        # Recommend periods
-        good_periods = []
-        if month in [1, 9]:
-            good_periods.append("New Year/Back-to-school - high user engagement")
-        if month in [10, 11]:
-            good_periods.append("Pre-holiday season - good for shopping/gift apps")
-
-        return {
-            'current_month': month,
-            'avoid_periods': avoid_periods,
-            'good_periods': good_periods
-        }
-
-    def _analyze_competitive_timing(self, app_category: str) -> Dict[str, str]:
-        """Analyze competitive timing considerations."""
-        return {
-            'recommendation': 'Research competitor launch schedules in your category',
-            'strategy': 'Avoid launching same week as major competitor updates'
-        }
-
-    def _calculate_optimal_dates(
-        self,
-        current_date: str,
-        day_rec: Dict[str, Any],
-        seasonal_rec: Dict[str, Any]
-    ) -> List[str]:
-        """Calculate optimal launch dates."""
-        current_dt = datetime.strptime(current_date, '%Y-%m-%d')
-
-        # Find next occurrence of recommended day
-        target_day = day_rec['recommended_day']
-        days_map = {'Monday': 0, 'Tuesday': 1, 'Wednesday': 2, 'Thursday': 3, 'Friday': 4}
-        target_day_num = days_map.get(target_day, 2)
-
-        days_ahead = (target_day_num - current_dt.weekday()) % 7
-        if days_ahead == 0:
-            days_ahead = 7
-
-        next_target_date = current_dt + timedelta(days=days_ahead)
-
-        optimal_dates = [
-            next_target_date.strftime('%Y-%m-%d'),
-            (next_target_date + timedelta(days=7)).strftime('%Y-%m-%d'),
-            (next_target_date + timedelta(days=14)).strftime('%Y-%m-%d')
-        ]
-
-        return optimal_dates
-
-    def _generate_timing_recommendation(
-        self,
-        optimal_dates: List[str],
-        seasonal_rec: Dict[str, Any]
-    ) -> str:
-        """Generate final timing recommendation."""
-        if seasonal_rec['avoid_periods']:
-            return f"Consider launching in {optimal_dates[1]} to avoid {seasonal_rec['avoid_periods'][0]}"
-        elif seasonal_rec['good_periods']:
-            return f"Launch on {optimal_dates[0]} to capitalize on {seasonal_rec['good_periods'][0]}"
-        else:
-            return f"Recommended launch date: {optimal_dates[0]}"
-
-    def _identify_seasonal_opportunities(
-        self,
-        app_category: str,
-        current_month: int
-    ) -> List[Dict[str, Any]]:
-        """Identify seasonal opportunities for category."""
-        opportunities = []
-
-        # Universal opportunities
-        if current_month == 1:
-            opportunities.append({
-                'event': 'New Year Resolutions',
-                'dates': 'January 1-31',
-                'relevance': 'high' if app_category.lower() in ['health', 'fitness', 'productivity'] else 'medium'
-            })
-
-        if current_month in [11, 12]:
-            opportunities.append({
-                'event': 'Holiday Shopping Season',
-                'dates': 'November-December',
-                'relevance': 'high' if app_category.lower() in ['shopping', 'gifts'] else 'low'
-            })
-
-        # Category-specific
-        if app_category.lower() == 'education' and current_month in [8, 9]:
-            opportunities.append({
-                'event': 'Back to School',
-                'dates': 'August-September',
-                'relevance': 'high'
-            })
-
-        return opportunities
-
-    def _generate_seasonal_campaign(self, opportunity: Dict[str, Any]) -> Dict[str, Any]:
-        """Generate campaign idea for seasonal opportunity."""
-        return {
-            'event': opportunity['event'],
-            'campaign_idea': f"Create themed visuals and messaging for {opportunity['event']}",
-            'metadata_updates': 'Update app description and screenshots with seasonal themes',
-            'promotion_strategy': 'Consider limited-time features or discounts'
-        }
-
-    def _create_seasonal_timeline(self, campaigns: List[Dict[str, Any]]) -> List[str]:
-        """Create implementation timeline for campaigns."""
-        return [
-            f"30 days before: Plan {campaign['event']} campaign strategy"
-            for campaign in campaigns
-        ]
-
-
-def generate_launch_checklist(
-    platform: str,
-    app_info: Dict[str, Any],
-    launch_date: Optional[str] = None
-) -> Dict[str, Any]:
-    """
-    Convenience function to generate launch checklist.
-
-    Args:
-        platform: Platform ('apple', 'google', or 'both')
-        app_info: App information
-        launch_date: Target launch date
-
-    Returns:
-        Complete launch checklist
-    """
-    generator = LaunchChecklistGenerator(platform)
-    return generator.generate_prelaunch_checklist(app_info, launch_date)