@hienlh/ppm 0.9.81 → 0.9.82

package/.opencode/skills/social/references/platform-specs.md

@@ -1,58 +0,0 @@
-# Platform Specifications
-
-## Content Limits & Optimal Sizes
-
-| Platform | Text Limit | Image Size | Video Length | Best Times |
-|----------|------------|------------|--------------|------------|
-| LinkedIn | 3000 chars | 1200x627 | 10 min | Tue-Thu 8-10am |
-| Twitter/X | 280 chars | 1600x900 | 2:20 | Tue-Fri 9am-12pm |
-| Instagram | 2200 chars | 1080x1080 | 90 sec (Reels) | Mon-Fri 11am-2pm |
-| Facebook | 63K chars | 1200x630 | 240 min | Wed-Fri 1-4pm |
-| TikTok | 4000 chars | 1080x1920 | 10 min | Tue-Thu 7-9pm |
-
-## Platform-Specific Features
-
-### LinkedIn
-- Document carousels (PDF, 10 slides max)
-- LinkedIn Live
-- Newsletters
-- Polls (2 weeks max)
-- Articles (long-form)
-
-### Twitter/X
-- Threads (unlimited tweets)
-- Spaces (audio rooms)
-- Communities
-- Polls (7 days max)
-- Circle (private sharing)
-
-### Instagram
-- Stories (24hr, 15 sec clips)
-- Reels (up to 90 sec)
-- Carousels (10 images)
-- Guides (curated collections)
-- Broadcast channels
-
-### Facebook
-- Groups
-- Events
-- Live video
-- Stories
-- Reels
-
-### TikTok
-- Duets
-- Stitches
-- Effects/filters
-- Live streams
-- Photo mode
-
-## Character Limits Detail
-
-| Platform | Post | Bio | Hashtags |
-|----------|------|-----|----------|
-| LinkedIn | 3000 | 2600 | 3-5 recommended |
-| Twitter/X | 280 | 160 | 1-2 recommended |
-| Instagram | 2200 | 150 | 20-30 in comments |
-| Facebook | 63K | 101 | 1-3 recommended |
-| TikTok | 4000 | 80 | 3-5 recommended |

package/.opencode/skills/social/references/posting-best-practices.md

@@ -1,61 +0,0 @@
-# Social Media Posting Best Practices
-
-## LinkedIn
-- Professional tone, insights-driven
-- Use line breaks for readability
-- Include 3-5 hashtags at end
-- Tag relevant connections
-- Add document carousels for engagement
-- Post native video over links
-- Engage in comments for 1 hour post-publish
-
-## Twitter/X
-- Conversational, punchy style
-- Use threads for longer content
-- Include 1-2 hashtags max
-- Reply to grow visibility
-- Retweet with commentary
-- Use visuals to boost engagement
-- Time-sensitive content works well
-
-## Instagram
-- Visual-first, high-quality images
-- Carousels outperform single posts
-- Use Stories for daily engagement
-- Reels for reach/discovery
-- 20-30 hashtags in first comment
-- Strong CTA in bio link
-- User-generated content performs well
-
-## Facebook
-- Community-focused content
-- Native video preferred
-- Ask questions to drive engagement
-- Groups for community building
-- Events for local/live activities
-- Share stories and behind-scenes
-
-## TikTok
-- Authentic, not polished
-- Hook in first 3 seconds
-- Use trending sounds
-- Participate in challenges
-- Respond with video comments
-- Post 1-3x per day for growth
-
-## Universal Best Practices
-
-1. **Consistency > Frequency**
-   - Better to post 3x/week consistently than 7x one week, 0 the next
-
-2. **Engage Before/After Posting**
-   - 15-30 min engagement before and after posting
-
-3. **Use Platform-Native Features**
-   - Algorithms favor native content
-
-4. **Respond to Comments Quickly**
-   - Within 1 hour ideally
-
-5. **Test and Iterate**
-   - Track what works for YOUR audience

package/.opencode/skills/social/references/rate-limits-errors.md

@@ -1,191 +0,0 @@
-# Rate Limits & Error Handling
-
-Cross-platform rate limit management and error recovery strategies.
-
-## Rate Limits by Platform
-
-| Platform | Max Concurrent | Token Expiry | Daily Limits |
-|----------|----------------|--------------|--------------|
-| X (Twitter) | 1 | Never (OAuth 1.0a) | 50 tweets (Basic), 300K/mo (Pro) |
-| LinkedIn | 2 | Needs refresh | Varies by tier |
-| Facebook | 100 | ~59 days | 200 calls/hour |
-| Threads | 2 | ~58 days | 250 posts/24h |
-| TikTok | 1 | ~23 hours | Varies by approval status |
-| YouTube | 200 | Needs refresh | 10K units/day |
-
-## Error Handling Pattern
-
-```typescript
-abstract class SocialAbstract {
-  async fetch(url: string, options: RequestInit = {}, retries = 0): Promise<Response> {
-    const response = await fetch(url, options);
-
-    if (response.ok) return response;
-
-    // Retry on rate limit or server error
-    if (retries < 3 && (response.status === 429 || response.status === 500)) {
-      await this.delay(5000 * (retries + 1)); // Exponential backoff
-      return this.fetch(url, options, retries + 1);
-    }
-
-    const body = await response.text();
-    const error = this.handleErrors(body);
-
-    if (error?.type === 'refresh-token') {
-      throw new RefreshTokenError(error.value);
-    }
-    if (error?.type === 'retry') {
-      await this.delay(5000);
-      return this.fetch(url, options, retries + 1);
-    }
-
-    throw new BadBodyError(error?.value || 'Unknown error');
-  }
-}
-```
-
-## Exponential Backoff
-
-```typescript
-async function withRetry<T>(
-  fn: () => Promise<T>,
-  maxRetries = 3,
-  baseDelay = 1000
-): Promise<T> {
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (i === maxRetries - 1) throw error;
-
-      const delay = baseDelay * Math.pow(2, i); // 1s, 2s, 4s...
-      await new Promise(r => setTimeout(r, delay));
-    }
-  }
-  throw new Error('Max retries exceeded');
-}
-```
-
-## Error Types
-
-```typescript
-// Refresh Token Error - Token expired, need re-auth
-class RefreshTokenError extends Error {
-  type = 'refresh-token';
-}
-
-// Bad Body Error - Content issue, don't retry
-class BadBodyError extends Error {
-  type = 'bad-body';
-}
-
-// Retry Error - Temporary issue, retry with backoff
-class RetryError extends Error {
-  type = 'retry';
-}
-```
-
-## Platform-Specific Error Codes
-
-### X (Twitter)
-| Code/Message | Type | Action |
-|--------------|------|--------|
-| `Unsupported Authentication` | refresh-token | Re-authenticate |
-| `usage-capped` | bad-body | Wait for quota reset |
-| `duplicate-rules` | bad-body | Content already posted |
-
-### LinkedIn
-| Code/Message | Type | Action |
-|--------------|------|--------|
-| `Unable to obtain activity` | retry | Retry with delay |
-
-### Facebook
-| Code | Type | Meaning |
-|------|------|---------|
-| `490` | refresh-token | Token expired |
-| `1366046` | bad-body | Image too large (>4MB) |
-| `1390008` | bad-body | Posting too fast |
-| `1404078` | refresh-token | Page auth required |
-| `1609008` | bad-body | Can't post FB links |
-
-### Threads
-| Code/Message | Type | Action |
-|--------------|------|--------|
-| `Error validating access token` | refresh-token | Re-authenticate |
-
-### TikTok
-| Code | Type | Meaning |
-|------|------|---------|
-| `access_token_invalid` | refresh-token | Token expired |
-| `rate_limit_exceeded` | bad-body | Too many requests |
-| `picture_size_check_failed` | bad-body | Min 720p required |
-| `spam_risk_too_many_posts` | bad-body | Daily limit |
-
-### YouTube
-| Code | Type | Meaning |
-|------|------|---------|
-| `invalidTitle` | bad-body | Title too long |
-| `uploadLimitExceeded` | bad-body | Daily quota |
-| `Unauthorized` | refresh-token | Token invalid |
-
-## Token Refresh Strategy
-
-```typescript
-interface TokenManager {
-  async getValidToken(integration: Integration): Promise<string> {
-    const expiresAt = integration.tokenExpiresAt;
-    const buffer = 5 * 60 * 1000; // 5 minute buffer
-
-    if (Date.now() > expiresAt - buffer) {
-      const newTokens = await this.refreshToken(integration);
-      await this.saveTokens(integration.id, newTokens);
-      return newTokens.accessToken;
-    }
-
-    return integration.accessToken;
-  }
-}
-```
-
-## Queue Management
-
-```typescript
-class PostQueue {
-  private queues: Map<string, Promise<void>> = new Map();
-
-  async enqueue(platform: string, job: () => Promise<void>): Promise<void> {
-    const existingQueue = this.queues.get(platform) || Promise.resolve();
-
-    const newQueue = existingQueue.then(async () => {
-      await job();
-      // Rate limit delay based on platform
-      await this.platformDelay(platform);
-    });
-
-    this.queues.set(platform, newQueue);
-    return newQueue;
-  }
-
-  private async platformDelay(platform: string): Promise<void> {
-    const delays: Record<string, number> = {
-      x: 2000,        // 2s between tweets
-      linkedin: 1000, // 1s between posts
-      facebook: 500,  // 0.5s between posts
-      threads: 3000,  // 3s between posts
-      tiktok: 5000,   // 5s between posts
-      youtube: 1000   // 1s between uploads
-    };
-    await new Promise(r => setTimeout(r, delays[platform] || 1000));
-  }
-}
-```
-
-## Best Practices
-
-1. **Token Refresh**: Always refresh before expiry, not after failure
-2. **Backoff**: Start at 1s, double each retry, cap at 60s
-3. **Concurrency**: Respect platform limits (see table above)
-4. **Caching**: Cache responses to reduce API calls
-5. **Circuit Breaker**: Disable platform temporarily after repeated failures
-6. **Logging**: Log all errors with full context for debugging
-7. **Alerts**: Notify on refresh-token errors (require user action)

package/.opencode/skills/social/references/schedule.md

@@ -1,50 +0,0 @@
-Create a social media schedule for optimal posting times.
-
-<period>$ARGUMENTS</period>
-
-## Periods
-- `week` - Weekly schedule
-- `month` - Monthly content calendar
-- `campaign [name]` - Campaign-specific schedule
-
-## Workflow
-
-1. **Gather Content**
-   - Scan `content/social/` for pending posts
-   - If empty, ask user for content topics
-
-2. **Timing Analysis**
-   - Use `social-media-manager` agent for optimal times
-   - Activate `social` skill for platform data
-   - Consider:
-     - Platform peak hours
-     - Audience timezone
-     - Content type best times
-
-3. **Create Schedule**
-   - Distribute content across period
-   - Balance platform coverage
-   - Avoid posting conflicts
-   - Generate calendar view
-
-4. **Output**
-   - Schedule → `assets/posts/schedule-{period}.md`
-   - Calendar export (if needed)
-
-## Agents Used
-- `social-media-manager` - Scheduling strategy
-
-## Skills Used
-- `social` - Platform timing data
-- `assets-organizing` - Standardized output paths
-
-## Output
-- Schedule → `assets/posts/schedule-{period}.md`
-- Calendar → `assets/posts/calendar-{period}.md`
-
-## Examples
-```
-/social/schedule week
-/social/schedule month
-/social/schedule campaign "Product Launch"
-```

package/.opencode/skills/social/references/thread-templates.md

@@ -1,72 +0,0 @@
-# Thread Templates
-
-## Thread Types
-
-### 1. Educational Thread
-```
-Tweet 1 (Hook): Here's what I learned about [topic] after [timeframe/experience]
-
-Tweet 2-N: [Key lessons, one per tweet]
-
-Final Tweet: TL;DR + CTA
-```
-
-### 2. Story Thread
-```
-Tweet 1: The time I [experience]... (Thread)
-
-Tweet 2: It started when [setup]
-
-Tweet 3-N: [Story progression]
-
-Final Tweet: The lesson + CTA
-```
-
-### 3. List Thread
-```
-Tweet 1: [Number] things every [audience] should know about [topic]:
-
-Tweet 2-N: [One item per tweet with explanation]
-
-Final Tweet: Summary + CTA
-```
-
-### 4. How-To Thread
-```
-Tweet 1: How to [achieve outcome] (step by step):
-
-Tweet 2-N: Step [N]: [Action + brief explanation]
-
-Final Tweet: Recap + CTA
-```
-
-### 5. Breakdown Thread
-```
-Tweet 1: Let me break down [complex topic] in simple terms:
-
-Tweet 2-N: [Concept explanations]
-
-Final Tweet: Summary + where to learn more
-```
-
-## Thread Best Practices
-
-1. **Hook is everything** - First tweet determines success
-2. **Keep tweets standalone** - Each should provide value
-3. **Use visuals** - Add images/screenshots where relevant
-4. **Number your tweets** - Makes following easier
-5. **End with CTA** - Follow, retweet, comment, link
-
-## Hook Formulas
-
-- "I spent [time] studying [topic]. Here's what I found:"
-- "Most people get [topic] wrong. Here's the truth:"
-- "[Controversial statement]. Here's why:"
-- "In [timeframe], I went from [state A] to [state B]. Here's how:"
-- "[Number] [things] that [outcome]. (Thread)"
-
-## Thread Length
-
-- **Minimum:** 4 tweets (hook + 2 content + CTA)
-- **Optimal:** 7-10 tweets
-- **Maximum:** 15-20 tweets (beyond gets fewer completions)

package/.opencode/skills/social/references/threads-workflow.md

@@ -1,198 +0,0 @@
-# Threads API Workflow
-
-Meta's Threads Graph API v1.0. OAuth 2.0 authentication.
-
-## Required Scopes
-
-```javascript
-const scopes = [
-  'threads_basic',
-  'threads_content_publish',
-  'threads_manage_replies',
-  'threads_manage_insights'
-];
-```
-
-## OAuth Flow
-
-```typescript
-// 1. Generate auth URL (requires HTTPS redirect)
-const authUrl = `https://threads.net/oauth/authorize?` +
-  `client_id=${THREADS_APP_ID}&` +
-  `redirect_uri=${encodeURIComponent(
-    redirectUri.includes('https') ? redirectUri : `https://redirectmeto.com/${redirectUri}`
-  )}&state=${state}&scope=${encodeURIComponent(scopes.join(','))}`;
-
-// 2. Exchange code for short-lived token
-const { access_token: shortToken } = await fetch(
-  `https://graph.threads.net/oauth/access_token?` +
-  `client_id=${THREADS_APP_ID}&redirect_uri=${redirectUri}&` +
-  `grant_type=authorization_code&client_secret=${THREADS_APP_SECRET}&code=${code}`
-).then(r => r.json());
-
-// 3. Exchange for long-lived token (58 days)
-const { access_token } = await fetch(
-  `https://graph.threads.net/access_token?grant_type=th_exchange_token&` +
-  `client_secret=${THREADS_APP_SECRET}&access_token=${shortToken}`
-).then(r => r.json());
-
-// 4. Refresh token (before expiry)
-const refreshed = await fetch(
-  `https://graph.threads.net/refresh_access_token?grant_type=th_refresh_token&access_token=${token}`
-).then(r => r.json());
-```
-
-## Get User Info
-
-```typescript
-const user = await fetch(
-  `https://graph.threads.net/v1.0/me?fields=id,username,threads_profile_picture_url&access_token=${token}`
-).then(r => r.json());
-```
-
-## Content Types
-
-### Text-Only Post
-```typescript
-const form = new FormData();
-form.append('media_type', 'TEXT');
-form.append('text', message);
-form.append('access_token', accessToken);
-
-const { id: contentId } = await fetch(
-  `https://graph.threads.net/v1.0/${userId}/threads`,
-  { method: 'POST', body: form }
-).then(r => r.json());
-```
-
-### Single Image/Video
-```typescript
-const isVideo = mediaPath.includes('.mp4');
-const params = new URLSearchParams({
-  [isVideo ? 'video_url' : 'image_url']: mediaPath,
-  media_type: isVideo ? 'VIDEO' : 'IMAGE',
-  text: message,
-  access_token: accessToken
-});
-
-const { id: mediaId } = await fetch(
-  `https://graph.threads.net/v1.0/${userId}/threads?${params}`,
-  { method: 'POST' }
-).then(r => r.json());
-```
-
-### Carousel (Multiple Media)
-```typescript
-// 1. Create carousel items (unpublished)
-const mediaIds = [];
-for (const media of mediaArray) {
-  const isVideo = media.path.includes('.mp4');
-  const params = new URLSearchParams({
-    [isVideo ? 'video_url' : 'image_url']: media.path,
-    media_type: isVideo ? 'VIDEO' : 'IMAGE',
-    is_carousel_item: 'true',
-    text: message,
-    access_token: accessToken
-  });
-  const { id } = await fetch(`https://graph.threads.net/v1.0/${userId}/threads?${params}`, { method: 'POST' }).then(r => r.json());
-  mediaIds.push(id);
-}
-
-// 2. Wait for all items to finish processing
-await Promise.all(mediaIds.map(id => checkMediaStatus(id, accessToken)));
-
-// 3. Create carousel container
-const carouselParams = new URLSearchParams({
-  text: message,
-  media_type: 'CAROUSEL',
-  children: mediaIds.join(','),
-  access_token: accessToken
-});
-const { id: containerId } = await fetch(`https://graph.threads.net/v1.0/${userId}/threads?${carouselParams}`, { method: 'POST' }).then(r => r.json());
-```
-
-## Check Media Status
-
-```typescript
-async function checkMediaStatus(mediaContainerId, accessToken) {
-  while (true) {
-    const { status, error_message } = await fetch(
-      `https://graph.threads.net/v1.0/${mediaContainerId}?fields=status,error_message&access_token=${accessToken}`
-    ).then(r => r.json());
-
-    if (status === 'ERROR') throw new Error(error_message);
-    if (status === 'FINISHED') return true;
-    await new Promise(r => setTimeout(r, 2200)); // Wait before retry
-  }
-}
-```
-
-## Publish Thread
-
-```typescript
-// Wait for content to be ready
-await checkMediaStatus(contentId, accessToken);
-await new Promise(r => setTimeout(r, 2000)); // Extra buffer
-
-// Publish
-const { id: threadId } = await fetch(
-  `https://graph.threads.net/v1.0/${userId}/threads_publish?creation_id=${contentId}&access_token=${accessToken}`,
-  { method: 'POST' }
-).then(r => r.json());
-
-// Get permalink
-const { permalink } = await fetch(
-  `https://graph.threads.net/v1.0/${threadId}?fields=id,permalink&access_token=${accessToken}`
-).then(r => r.json());
-```
-
-## Reply Thread
-
-```typescript
-// Create reply content (same as post but with reply_to_id)
-const form = new FormData();
-form.append('media_type', 'TEXT');
-form.append('text', replyMessage);
-form.append('reply_to_id', parentThreadId);
-form.append('access_token', accessToken);
-
-const { id: replyContentId } = await fetch(
-  `https://graph.threads.net/v1.0/${userId}/threads`,
-  { method: 'POST', body: form }
-).then(r => r.json());
-
-// Publish reply
-await checkMediaStatus(replyContentId, accessToken);
-const { id: replyThreadId } = await fetch(
-  `https://graph.threads.net/v1.0/${userId}/threads_publish?creation_id=${replyContentId}&access_token=${accessToken}`,
-  { method: 'POST' }
-).then(r => r.json());
-```
-
-## Quote Post
-
-```typescript
-const form = new FormData();
-form.append('media_type', 'TEXT');
-form.append('text', message);
-form.append('quote_post_id', quotedThreadId);
-form.append('access_token', accessToken);
-```
-
-## Analytics
-
-```typescript
-const { data } = await fetch(
-  `https://graph.threads.net/v1.0/${userId}/threads_insights?` +
-  `metric=views,likes,replies,reposts,quotes&access_token=${accessToken}&` +
-  `period=day&since=${since}&until=${until}`
-).then(r => r.json());
-```
-
-## Rate Limits & Constraints
-
-- Max concurrent: 2 jobs
-- Max post length: 500 characters
-- Requires HTTPS redirect (use redirectmeto.com for local dev)
-- Token refresh: ~58 days lifespan
-- Carousel: Max items depend on Threads limits