codehava-agent-kit 1.0.0 → 2.0.0

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

@@ -0,0 +1,739 @@
+"""
+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)