gkt-node 3.3.0

package/assets/.agent/skills/content-creator/references/social_media_optimization.md

@@ -0,0 +1,317 @@
+# Social Media Optimization Guide
+
+## Platform-Specific Best Practices
+
+### LinkedIn
+**Audience**: B2B professionals, decision-makers, thought leaders
+**Best Times**: Tuesday-Thursday, 8-10 AM and 5-6 PM
+**Optimal Length**: 1,300-2,000 characters for posts
+
+#### Content Formats
+- **Text Posts**: 1,300 characters optimal, use line breaks
+- **Articles**: 1,900-2,000 words, include 5+ images
+- **Videos**: 30 seconds - 10 minutes, native upload preferred
+- **Documents**: PDF carousels, 10-15 slides
+- **Polls**: 4 options max, 1-2 week duration
+
+#### Optimization Tips
+- First 2 lines are crucial (shown in preview)
+- Use emoji sparingly for visual breaks 
+- Include 3-5 relevant hashtags
+- Tag people and companies when relevant
+- Native video gets 5x more engagement
+- Post consistently (3-5x per week optimal)
+
+#### Algorithm Factors
+- Dwell time (time spent reading)
+- Comments valued over likes
+- Early engagement (first hour) crucial
+- Creator mode boosts reach
+- Replies to comments increase visibility
+
+### Twitter/X
+**Audience**: News junkies, tech enthusiasts, real-time conversation
+**Best Times**: Weekdays 9-10 AM and 7-9 PM
+**Optimal Length**: 100-250 characters
+
+#### Content Formats
+- **Single Tweets**: 250 characters, 1-2 hashtags
+- **Threads**: 5-15 tweets, numbered format
+- **Images**: 16:9 ratio, up to 4 per tweet
+- **Videos**: Up to 2:20, square or landscape
+- **Polls**: 2-4 options, 5 minutes - 7 days
+
+#### Optimization Tips
+- Front-load important information
+- Use threads for complex topics
+- Include visuals (2-3x more engagement)
+- Retweet with comment > regular RT
+- Schedule threads for consistency
+- Engage genuinely with replies
+
+#### Algorithm Factors
+- Engagement rate (likes, RTs, replies)
+- Relationship (mutual follows prioritized)
+- Recency over evergreen
+- Topic relevance to user interests
+- Link posts receive less reach
+
+### Instagram
+**Audience**: Visual-first, millennials & Gen Z, lifestyle focused
+**Best Times**: Weekdays 11 AM - 1 PM and 7-9 PM
+**Optimal Length**: 138-150 characters shown in preview
+
+#### Content Formats
+- **Feed Posts**: Square (1:1) or vertical (4:5)
+- **Stories**: 15 seconds max, vertical (9:16)
+- **Reels**: 15-90 seconds, vertical (9:16)
+- **Carousels**: 2-10 images/videos
+- **IGTV/Video**: 1-60 minutes
+
+#### Optimization Tips
+- First sentence crucial (caption preview)
+- Use up to 30 hashtags (5-10 in caption, rest in comment)
+- Carousel posts get highest engagement
+- Stories with polls/questions boost views
+- Reels get maximum organic reach
+- Post consistently (1-2 feed posts daily)
+
+#### Algorithm Factors
+- Relationship (DMs, comments, tags)
+- Interest (based on past interactions)
+- Timeliness (newer posts prioritized)
+- Frequency of app usage
+- Time spent on posts (saves valuable)
+
+### Facebook
+**Audience**: Broad demographic, community-focused, local businesses
+**Best Times**: Wednesday-Friday, 11 AM - 2 PM
+**Optimal Length**: 50-80 characters for posts
+
+#### Content Formats
+- **Text Posts**: 50-80 characters optimal
+- **Images**: 1200x630px for links
+- **Videos**: 1-3 minutes, square format
+- **Stories**: Same as Instagram
+- **Live Videos**: Minimum 10 minutes
+
+#### Optimization Tips
+- Native video gets priority
+- Ask questions to boost comments
+- Share to relevant groups
+- Use Facebook Creator Studio
+- Tag locations for local reach
+- Post 1-2 times per day max
+
+#### Algorithm Factors
+- Meaningful interactions (comments > reactions)
+- Video completion rate
+- Friends and family prioritized
+- Group posts get high visibility
+- Live videos get 6x engagement
+
+### TikTok
+**Audience**: Gen Z, entertainment-focused, trend-driven
+**Best Times**: 6-10 AM and 7-11 PM
+**Optimal Length**: 15-30 seconds
+
+#### Content Formats
+- **Videos**: 15 seconds - 10 minutes
+- **Aspect Ratio**: 9:16 vertical
+- **Sounds**: Trending audio crucial
+- **Effects**: Filters and transitions
+
+#### Optimization Tips
+- Hook viewers in first 3 seconds
+- Use trending sounds and hashtags
+- Create content for FYP, not followers
+- Post 1-4 times daily
+- Engage with comments quickly
+- Jump on trends within 24-48 hours
+
+#### Algorithm Factors
+- Completion rate most important
+- Shares and saves valued
+- Comment engagement
+- Following similar creators
+- Time spent on app
+
+## Content Optimization Strategies
+
+### Hashtag Strategy
+
+#### Research Methods
+1. **Competitor Analysis**: Study successful competitors
+2. **Platform Search**: Use native search for suggestions
+3. **Hashtag Tools**: RiteTag, Hashtagify, All Hashtag
+4. **Trending Topics**: Monitor daily/weekly trends
+5. **Brand Hashtags**: Create unique campaign tags
+
+#### Hashtag Mix Formula
+- 30% High-volume (1M+ posts)
+- 40% Medium-volume (100K-1M posts)
+- 30% Low-volume/Niche (<100K posts)
+
+#### Platform-Specific Guidelines
+- **Instagram**: 10-30 hashtags (mix in caption and first comment)
+- **LinkedIn**: 3-5 professional hashtags
+- **Twitter**: 1-2 hashtags max
+- **Facebook**: 1-3 hashtags
+- **TikTok**: 3-5 trending + niche tags
+
+### Visual Content Optimization
+
+#### Image Best Practices
+- **Resolution**: Minimum 1080px width
+- **File Size**: Under 5MB for faster loading
+- **Alt Text**: Always include for accessibility
+- **Branding**: Consistent filters/overlays
+- **Text Overlay**: Less than 20% of image
+
+#### Video Optimization
+- **Captions**: Always include (85% watch without sound)
+- **Thumbnail**: Custom, eye-catching
+- **Length**: Platform-specific optimal duration
+- **Format**: MP4 for best compatibility
+- **Aspect Ratio**: Vertical for stories/reels, square for feed
+
+### Caption Writing Formulas
+
+#### AIDA Formula
+- **Attention**: Hook in first line
+- **Interest**: Expand on the hook
+- **Desire**: Benefits and value
+- **Action**: Clear CTA
+
+#### PAS Formula
+- **Problem**: Identify pain point
+- **Agitate**: Emphasize consequences
+- **Solution**: Present your answer
+
+#### Before-After-Bridge
+- **Before**: Current situation
+- **After**: Desired outcome
+- **Bridge**: How to get there
+
+### Engagement Tactics
+
+#### Conversation Starters
+- Ask open-ended questions
+- Create polls and surveys
+- "Fill in the blank" posts
+- "This or that" choices
+- Caption contests
+- Opinion requests
+
+#### Community Building
+- Respond to comments within 2 hours
+- Like and reply to user comments
+- Share user-generated content
+- Create branded hashtags
+- Host Q&A sessions
+- Run challenges or contests
+
+### Analytics & KPIs
+
+#### Vanity Metrics (Track but don't obsess)
+- Follower count
+- Like count
+- View count
+
+#### Performance Metrics (Focus here)
+- Engagement rate: (Likes + Comments + Shares) / Reach × 100
+- Click-through rate: Clicks / Impressions × 100
+- Conversion rate: Conversions / Clicks × 100
+- Share/Save rate: Shares / Reach × 100
+
+#### Business Metrics (Ultimate goal)
+- Website traffic from social
+- Lead generation
+- Sales attribution
+- Customer acquisition cost
+- Customer lifetime value
+
+### Content Calendar Planning
+
+#### Weekly Posting Schedule Template
+```
+Monday: Motivational (Quote/Inspiration)
+Tuesday: Educational (How-to/Tips)
+Wednesday: Promotional (Product/Service)
+Thursday: Engaging (Poll/Question)
+Friday: Fun (Behind-scenes/Casual)
+Saturday: User-Generated Content
+Sunday: Curated Content/Rest
+```
+
+#### Monthly Theme Structure
+- Week 1: Awareness content
+- Week 2: Consideration content
+- Week 3: Decision content
+- Week 4: Retention/Community
+
+### Crisis Management Protocol
+
+#### Response Timeline
+- **0-15 minutes**: Acknowledge awareness
+- **15-60 minutes**: Gather facts
+- **1-2 hours**: Official response
+- **24 hours**: Follow-up update
+- **48-72 hours**: Resolution summary
+
+#### Response Guidelines
+1. Acknowledge quickly
+2. Take responsibility if appropriate
+3. Show empathy
+4. Provide facts only
+5. Outline action steps
+6. Follow up publicly
+
+## Tool Stack Recommendations
+
+### Content Creation
+- **Design**: Canva, Adobe Creative Suite
+- **Video**: CapCut, InShot, Adobe Premiere
+- **Copy**: Grammarly, Hemingway Editor
+- **AI Assistance**: ChatGPT, Claude, Jasper
+
+### Scheduling & Management
+- **All-in-One**: Hootsuite, Buffer, Sprout Social
+- **Visual-First**: Later, Planoly
+- **Enterprise**: Sprinklr, Khoros
+- **Free Options**: Meta Business Suite, TweetDeck
+
+### Analytics & Monitoring
+- **Native**: Platform Insights/Analytics
+- **Third-Party**: Socialbakers, Brandwatch
+- **Listening**: Mention, Brand24
+- **Competitor Analysis**: Social Blade, Rival IQ
+
+### Influencer & UGC
+- **Discovery**: AspireIQ, GRIN
+- **Management**: CreatorIQ, Klear
+- **UGC Curation**: TINT, Stackla
+- **Rights Management**: Rights Manager
+
+## Compliance & Best Practices
+
+### Legal Considerations
+- Include #ad or #sponsored for paid partnerships
+- Respect copyright and attribution
+- Follow GDPR for data collection
+- Comply with platform terms of service
+- Get permission for UGC usage
+
+### Accessibility Guidelines
+- Add alt text to all images
+- Include captions on videos
+- Use CamelCase for hashtags (#LikeThis)
+- Avoid text-only images
+- Ensure color contrast compliance
+
+### Brand Safety
+- Moderate comments regularly
+- Set up keyword filters
+- Have crisis management plan
+- Monitor brand mentions
+- Establish posting permissions

package/assets/.agent/skills/content-creator/scripts/brand_voice_analyzer.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+Brand Voice Analyzer - Analyzes content to establish and maintain brand voice consistency
+"""
+
+import re
+from typing import Dict, List, Tuple
+import json
+
+class BrandVoiceAnalyzer:
+    def __init__(self):
+        self.voice_dimensions = {
+            'formality': {
+                'formal': ['hereby', 'therefore', 'furthermore', 'pursuant', 'regarding'],
+                'casual': ['hey', 'cool', 'awesome', 'stuff', 'yeah', 'gonna']
+            },
+            'tone': {
+                'professional': ['expertise', 'solution', 'optimize', 'leverage', 'strategic'],
+                'friendly': ['happy', 'excited', 'love', 'enjoy', 'together', 'share']
+            },
+            'perspective': {
+                'authoritative': ['proven', 'research shows', 'experts agree', 'data indicates'],
+                'conversational': ['you might', 'let\'s explore', 'we think', 'imagine if']
+            }
+        }
+    
+    def analyze_text(self, text: str) -> Dict:
+        """Analyze text for brand voice characteristics"""
+        text_lower = text.lower()
+        word_count = len(text.split())
+        
+        results = {
+            'word_count': word_count,
+            'readability_score': self._calculate_readability(text),
+            'voice_profile': {},
+            'sentence_analysis': self._analyze_sentences(text),
+            'recommendations': []
+        }
+        
+        # Analyze voice dimensions
+        for dimension, categories in self.voice_dimensions.items():
+            dim_scores = {}
+            for category, keywords in categories.items():
+                score = sum(1 for keyword in keywords if keyword in text_lower)
+                dim_scores[category] = score
+            
+            # Determine dominant voice
+            if sum(dim_scores.values()) > 0:
+                dominant = max(dim_scores, key=dim_scores.get)
+                results['voice_profile'][dimension] = {
+                    'dominant': dominant,
+                    'scores': dim_scores
+                }
+        
+        # Generate recommendations
+        results['recommendations'] = self._generate_recommendations(results)
+        
+        return results
+    
+    def _calculate_readability(self, text: str) -> float:
+        """Calculate Flesch Reading Ease score"""
+        sentences = re.split(r'[.!?]+', text)
+        words = text.split()
+        syllables = sum(self._count_syllables(word) for word in words)
+        
+        if len(sentences) == 0 or len(words) == 0:
+            return 0
+        
+        avg_sentence_length = len(words) / len(sentences)
+        avg_syllables_per_word = syllables / len(words)
+        
+        # Flesch Reading Ease formula
+        score = 206.835 - 1.015 * avg_sentence_length - 84.6 * avg_syllables_per_word
+        return max(0, min(100, score))
+    
+    def _count_syllables(self, word: str) -> int:
+        """Count syllables in a word (simplified)"""
+        word = word.lower()
+        vowels = 'aeiou'
+        syllable_count = 0
+        previous_was_vowel = False
+        
+        for char in word:
+            is_vowel = char in vowels
+            if is_vowel and not previous_was_vowel:
+                syllable_count += 1
+            previous_was_vowel = is_vowel
+        
+        # Adjust for silent e
+        if word.endswith('e'):
+            syllable_count -= 1
+        
+        return max(1, syllable_count)
+    
+    def _analyze_sentences(self, text: str) -> Dict:
+        """Analyze sentence structure"""
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        
+        if not sentences:
+            return {'average_length': 0, 'variety': 'low'}
+        
+        lengths = [len(s.split()) for s in sentences]
+        avg_length = sum(lengths) / len(lengths) if lengths else 0
+        
+        # Calculate variety
+        if len(set(lengths)) < 3:
+            variety = 'low'
+        elif len(set(lengths)) < 5:
+            variety = 'medium'
+        else:
+            variety = 'high'
+        
+        return {
+            'average_length': round(avg_length, 1),
+            'variety': variety,
+            'count': len(sentences)
+        }
+    
+    def _generate_recommendations(self, analysis: Dict) -> List[str]:
+        """Generate recommendations based on analysis"""
+        recommendations = []
+        
+        # Readability recommendations
+        if analysis['readability_score'] < 30:
+            recommendations.append("Consider simplifying language for better readability")
+        elif analysis['readability_score'] > 70:
+            recommendations.append("Content is very easy to read - consider if this matches your audience")
+        
+        # Sentence variety
+        if analysis['sentence_analysis']['variety'] == 'low':
+            recommendations.append("Vary sentence length for better flow and engagement")
+        
+        # Voice consistency
+        if analysis['voice_profile']:
+            recommendations.append("Maintain consistent voice across all content")
+        
+        return recommendations
+
+def analyze_content(content: str, output_format: str = 'json') -> str:
+    """Main function to analyze content"""
+    analyzer = BrandVoiceAnalyzer()
+    results = analyzer.analyze_text(content)
+    
+    if output_format == 'json':
+        return json.dumps(results, indent=2)
+    else:
+        # Human-readable format
+        output = [
+            f"=== Brand Voice Analysis ===",
+            f"Word Count: {results['word_count']}",
+            f"Readability Score: {results['readability_score']:.1f}/100",
+            f"",
+            f"Voice Profile:"
+        ]
+        
+        for dimension, profile in results['voice_profile'].items():
+            output.append(f"  {dimension.title()}: {profile['dominant']}")
+        
+        output.extend([
+            f"",
+            f"Sentence Analysis:",
+            f"  Average Length: {results['sentence_analysis']['average_length']} words",
+            f"  Variety: {results['sentence_analysis']['variety']}",
+            f"  Total Sentences: {results['sentence_analysis']['count']}",
+            f"",
+            f"Recommendations:"
+        ])
+        
+        for rec in results['recommendations']:
+            output.append(f"  • {rec}")
+        
+        return '\n'.join(output)
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'r') as f:
+            content = f.read()
+        
+        output_format = sys.argv[2] if len(sys.argv) > 2 else 'text'
+        print(analyze_content(content, output_format))
+    else:
+        print("Usage: python brand_voice_analyzer.py <file> [json|text]")