thumbgate 0.9.9 → 0.9.11

package/scripts/social-analytics/schedule-thumbgate-campaign.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { publishInstagramThumbGate } = require('./publish-instagram-thumbgate');
+const {
+  DEFAULT_TIMEZONE,
+  buildCampaignEntries,
+  defaultCampaignSchedule,
+} = require('./publish-thumbgate-launch');
+const {
+  getConnectedAccounts,
+  groupAccountsByPlatform,
+  schedulePost,
+} = require('./publishers/zernio');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_STATE_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-campaign-schedule-state.json');
+
+function parseArgs(argv = []) {
+  const options = {
+    dryRun: false,
+    platforms: [],
+    scheduleTimes: [],
+    statePath: DEFAULT_STATE_PATH,
+    timezone: DEFAULT_TIMEZONE,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (token.startsWith('--platforms=')) {
+      options.platforms = token.slice('--platforms='.length).split(',').map((value) => value.trim()).filter(Boolean);
+      continue;
+    }
+
+    if (token === '--platforms' && argv[index + 1]) {
+      options.platforms = String(argv[index + 1]).split(',').map((value) => value.trim()).filter(Boolean);
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith('--times=')) {
+      options.scheduleTimes = token.slice('--times='.length).split(',').map((value) => value.trim()).filter(Boolean);
+      continue;
+    }
+
+    if (token === '--times' && argv[index + 1]) {
+      options.scheduleTimes = String(argv[index + 1]).split(',').map((value) => value.trim()).filter(Boolean);
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith('--timezone=')) {
+      options.timezone = token.slice('--timezone='.length).trim() || DEFAULT_TIMEZONE;
+      continue;
+    }
+
+    if (token.startsWith('--state-path=')) {
+      options.statePath = token.slice('--state-path='.length).trim() || DEFAULT_STATE_PATH;
+      continue;
+    }
+
+    if (token === '--timezone' && argv[index + 1]) {
+      options.timezone = String(argv[index + 1]).trim() || DEFAULT_TIMEZONE;
+      index += 1;
+      continue;
+    }
+
+    if (token === '--state-path' && argv[index + 1]) {
+      options.statePath = String(argv[index + 1]).trim() || DEFAULT_STATE_PATH;
+      index += 1;
+    }
+  }
+
+  return options;
+}
+
+function readScheduleState(statePath = DEFAULT_STATE_PATH) {
+  if (!fs.existsSync(statePath)) {
+    return { scheduled: {} };
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  } catch {
+    return { scheduled: {} };
+  }
+}
+
+function writeScheduleState(statePath = DEFAULT_STATE_PATH, state = { scheduled: {} }) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function buildScheduleKey({ slug, platform, scheduledFor }) {
+  return `${scheduledFor}::${slug}::${platform}`;
+}
+
+async function scheduleCampaign(options = {}, api = {}) {
+  const scheduleApi = {
+    getConnectedAccounts: api.getConnectedAccounts || getConnectedAccounts,
+    groupAccountsByPlatform: api.groupAccountsByPlatform || groupAccountsByPlatform,
+    publishInstagramThumbGate: api.publishInstagramThumbGate || publishInstagramThumbGate,
+    schedulePost: api.schedulePost || schedulePost,
+  };
+
+  const campaignEntries = buildCampaignEntries();
+  const scheduleTimes = options.scheduleTimes && options.scheduleTimes.length > 0
+    ? options.scheduleTimes
+    : defaultCampaignSchedule();
+  const platforms = options.platforms && options.platforms.length > 0
+    ? options.platforms
+    : ['twitter', 'linkedin', 'instagram'];
+  const statePath = options.statePath || DEFAULT_STATE_PATH;
+  const state = readScheduleState(statePath);
+  const scheduledState = state.scheduled && typeof state.scheduled === 'object' ? state.scheduled : {};
+  const accounts = await scheduleApi.getConnectedAccounts();
+  const groupedAccounts = scheduleApi.groupAccountsByPlatform(accounts);
+  const results = {
+    dryRun: options.dryRun === true,
+    statePath,
+    timezone: options.timezone || DEFAULT_TIMEZONE,
+    scheduleTimes,
+    platforms,
+    scheduled: [],
+    skipped: [],
+    errors: [],
+  };
+
+  for (let index = 0; index < campaignEntries.length; index += 1) {
+    const entry = campaignEntries[index];
+    const scheduledFor = scheduleTimes[index];
+    if (!scheduledFor) {
+      results.skipped.push({ slug: entry.slug, reason: 'missing_schedule_time' });
+      continue;
+    }
+
+    for (const platform of platforms) {
+      const normalizedPlatform = String(platform || '').trim().toLowerCase();
+      const platformAccounts = groupedAccounts.get(normalizedPlatform) || [];
+      if (platformAccounts.length === 0) {
+        results.skipped.push({ slug: entry.slug, platform: normalizedPlatform, reason: 'not_connected' });
+        continue;
+      }
+
+      const content = entry.posts[normalizedPlatform];
+      if (!content) {
+        results.skipped.push({ slug: entry.slug, platform: normalizedPlatform, reason: 'no_content' });
+        continue;
+      }
+
+      const scheduleKey = buildScheduleKey({
+        slug: entry.slug,
+        platform: normalizedPlatform,
+        scheduledFor,
+      });
+      if (!results.dryRun && scheduledState[scheduleKey]) {
+        results.skipped.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          reason: 'already_scheduled',
+          scheduledFor,
+          existing: scheduledState[scheduleKey],
+        });
+        continue;
+      }
+
+      if (results.dryRun) {
+        results.scheduled.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          scheduledFor,
+          dryRun: true,
+          content,
+        });
+        continue;
+      }
+
+      const utm = {
+        source: normalizedPlatform === 'twitter' ? 'x' : normalizedPlatform,
+        medium: 'organic_social',
+        campaign: 'first_customer_push',
+      };
+
+      try {
+        if (normalizedPlatform === 'instagram') {
+          const scheduledResult = await scheduleApi.publishInstagramThumbGate({
+            caption: content,
+            schedule: scheduledFor,
+            timezone: options.timezone || DEFAULT_TIMEZONE,
+            utm,
+          });
+          scheduledState[scheduleKey] = {
+            id: scheduledResult.postId || scheduledResult.id || null,
+            scheduledFor,
+            slug: entry.slug,
+            platform: normalizedPlatform,
+            recordedAt: new Date().toISOString(),
+          };
+          results.scheduled.push({
+            slug: entry.slug,
+            platform: normalizedPlatform,
+            scheduledFor,
+            result: scheduledResult,
+          });
+          continue;
+        }
+
+        const scheduledResult = await scheduleApi.schedulePost(
+          content,
+          platformAccounts,
+          scheduledFor,
+          options.timezone || DEFAULT_TIMEZONE,
+          { utm }
+        );
+        scheduledState[scheduleKey] = {
+          id: scheduledResult.id || scheduledResult.post?._id || null,
+          scheduledFor,
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          recordedAt: new Date().toISOString(),
+        };
+        results.scheduled.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          scheduledFor,
+          result: scheduledResult,
+        });
+      } catch (error) {
+        results.errors.push({
+          slug: entry.slug,
+          platform: normalizedPlatform,
+          error: error && error.message ? error.message : String(error),
+        });
+      }
+    }
+  }
+
+  if (!results.dryRun) {
+    writeScheduleState(statePath, { scheduled: scheduledState });
+  }
+
+  return results;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const results = await scheduleCampaign(options);
+  process.stdout.write(`${JSON.stringify(results, null, 2)}\n`);
+  if (results.errors.length > 0) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(error && error.message ? error.message : error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  buildScheduleKey,
+  DEFAULT_STATE_PATH,
+  parseArgs,
+  readScheduleState,
+  scheduleCampaign,
+  writeScheduleState,
+};

package/scripts/social-analytics/sync-launch-assets.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  listPosts,
+} = require('./publishers/zernio');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_STATE_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-launch-assets.json');
+
+const LAUNCH_MARKERS = {
+  twitter: 'launch_post_twitter',
+  linkedin: 'launch_post_linkedin',
+  instagram: 'launch_post_instagram',
+  reddit: 'launch_post_reddit',
+};
+
+const CAMPAIGN_MARKERS = {
+  proof_pack: 'campaign_proof_pack',
+  free_local: 'campaign_free_local',
+  checkout_path: 'campaign_checkout_path',
+};
+
+function parseArgs(argv = []) {
+  const options = {
+    limit: 50,
+    statePath: DEFAULT_STATE_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = String(argv[index] || '').trim();
+    if (token.startsWith('--limit=')) {
+      options.limit = Number.parseInt(token.slice('--limit='.length), 10) || options.limit;
+      continue;
+    }
+    if (token === '--limit' && argv[index + 1]) {
+      options.limit = Number.parseInt(String(argv[index + 1]), 10) || options.limit;
+      index += 1;
+      continue;
+    }
+    if (token.startsWith('--state-path=')) {
+      options.statePath = token.slice('--state-path='.length).trim() || DEFAULT_STATE_PATH;
+      continue;
+    }
+    if (token === '--state-path' && argv[index + 1]) {
+      options.statePath = String(argv[index + 1]).trim() || DEFAULT_STATE_PATH;
+      index += 1;
+    }
+  }
+
+  return options;
+}
+
+function normalizePlatform(post = {}) {
+  return String(post?.platforms?.[0]?.platform || '').trim().toLowerCase();
+}
+
+function extractMarker(post = {}) {
+  const content = String(post.content || '');
+
+  for (const marker of Object.values(LAUNCH_MARKERS)) {
+    if (content.includes(`utm_content=${marker}`)) {
+      return marker;
+    }
+  }
+
+  for (const marker of Object.values(CAMPAIGN_MARKERS)) {
+    if (content.includes(`utm_content=${marker}`)) {
+      return marker;
+    }
+  }
+
+  return '';
+}
+
+function toTimestamp(post = {}) {
+  return new Date(post.createdAt || post.updatedAt || post.scheduledFor || 0).getTime();
+}
+
+function selectNewestPost(posts = []) {
+  return [...posts].sort((left, right) => toTimestamp(right) - toTimestamp(left))[0] || null;
+}
+
+function summarizePost(post = {}, marker = '') {
+  return {
+    id: post._id || post.id || null,
+    platform: normalizePlatform(post),
+    status: post.status || null,
+    marker,
+    createdAt: post.createdAt || null,
+    updatedAt: post.updatedAt || null,
+    scheduledFor: post.scheduledFor || null,
+    content: post.content || '',
+  };
+}
+
+function buildLaunchAssetState(posts = []) {
+  const state = {
+    updatedAt: new Date().toISOString(),
+    launchPosts: {},
+    campaignPosts: {},
+  };
+
+  for (const [platform, marker] of Object.entries(LAUNCH_MARKERS)) {
+    const matching = posts.filter((post) => extractMarker(post) === marker);
+    const selected = selectNewestPost(matching);
+    if (selected) {
+      state.launchPosts[platform] = summarizePost(selected, marker);
+    }
+  }
+
+  for (const [slug, marker] of Object.entries(CAMPAIGN_MARKERS)) {
+    const matching = posts.filter((post) => extractMarker(post) === marker);
+    if (matching.length === 0) {
+      continue;
+    }
+
+    const byPlatform = {};
+    for (const post of matching) {
+      const platform = normalizePlatform(post);
+      if (!platform) continue;
+      const existing = byPlatform[platform];
+      if (!existing || toTimestamp(post) > toTimestamp(existing)) {
+        byPlatform[platform] = post;
+      }
+    }
+
+    state.campaignPosts[slug] = {};
+    for (const [platform, post] of Object.entries(byPlatform)) {
+      state.campaignPosts[slug][platform] = summarizePost(post, marker);
+    }
+  }
+
+  return state;
+}
+
+function writeLaunchAssetState(statePath = DEFAULT_STATE_PATH, state = {}) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  return statePath;
+}
+
+async function syncLaunchAssets(options = {}, api = {}) {
+  const zernio = {
+    listPosts: api.listPosts || listPosts,
+  };
+
+  const posts = await zernio.listPosts({ limit: options.limit || 50 });
+  const state = buildLaunchAssetState(Array.isArray(posts) ? posts : []);
+  const statePath = options.statePath || DEFAULT_STATE_PATH;
+  writeLaunchAssetState(statePath, state);
+  return {
+    statePath,
+    launchCount: Object.keys(state.launchPosts).length,
+    campaignCount: Object.keys(state.campaignPosts).length,
+    state,
+  };
+}
+
+if (require.main === module) {
+  syncLaunchAssets(parseArgs(process.argv.slice(2)))
+    .then((result) => {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    })
+    .catch((error) => {
+      console.error(error && error.message ? error.message : error);
+      process.exit(1);
+    });
+}
+
+module.exports = {
+  CAMPAIGN_MARKERS,
+  DEFAULT_STATE_PATH,
+  LAUNCH_MARKERS,
+  buildLaunchAssetState,
+  extractMarker,
+  normalizePlatform,
+  parseArgs,
+  selectNewestPost,
+  summarizePost,
+  syncLaunchAssets,
+  writeLaunchAssetState,
+};

package/scripts/social-pipeline.js

@@ -25,8 +25,8 @@ const DEFAULT_CAPTION_PATH = path.join(
   'pre-action-gates-caption.txt'
 );
 const DEFAULT_OUTPUT_ROOT = path.join(REPO_ROOT, '.artifacts', 'social');
-const DEFAULT_QUEUE_PATH = path.join(REPO_ROOT, '.rlhf', 'social-post-queue.json');
-const DEFAULT_HISTORY_PATH = path.join(REPO_ROOT, '.rlhf', 'social-post-history.jsonl');
+const DEFAULT_QUEUE_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-post-queue.json');
+const DEFAULT_HISTORY_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-post-history.jsonl');
 const DEFAULT_LAUNCHD_LABEL = 'io.github.IgorGanapolsky.thumbgate.social';
 const DEFAULT_SCHEDULE_INTERVAL_MINUTES = 15;
 const DEFAULT_CHROME_PROFILE_ROOT = path.join(

package/scripts/social-post-hourly.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * social-post-hourly.js → now "social-post-daily.js" in practice
+ *
+ * Generates ONE quality social post per day and publishes via Zernio
+ * to LinkedIn, X/Twitter, and TikTok (text-friendly platforms).
+ *
+ * Strategy based on research of top SaaS companies (Linear, Vercel, Supabase,
+ * PostHog, Cursor, Raycast, Cal.com):
+ * - 1 post/day, not 24. Quality over volume.
+ * - Rotate 7 content angles across the week (not 4 recycled hourly).
+ * - Content ratio: 30% educational, 25% product demo, 25% community, 20% hot takes.
+ * - NO Reddit auto-posting (ban risk). Reddit engagement via reply-monitor only.
+ * - NO Dev.to auto-posting (counterproductive at high volume).
+ *
+ * Runs daily via CI (.github/workflows/social-engagement-hourly.yml at 2pm UTC).
+ *
+ * Usage:
+ *   node scripts/social-post-hourly.js            # publish for real
+ *   node scripts/social-post-hourly.js --dry-run   # preview only
+ */
+
+require('dotenv').config();
+
+const { generateWeeklyStatsPost } = require('./daily-digest');
+const { publishPost, getConnectedAccounts } = require('./social-analytics/publishers/zernio');
+
+// Platforms that support text-only posts.
+// Reddit EXCLUDED — engagement only via reply-monitor, not auto-posting.
+// Instagram EXCLUDED — requires media.
+// TikTok EXCLUDED — requires video.
+const TEXT_PLATFORMS = new Set(['linkedin', 'twitter']);
+
+// 7 angles, one per day of the week (Monday=0 through Sunday=6)
+// Ratio: 2 educational, 2 product, 2 hot-take/community, 1 tip
+const DAILY_ANGLES = [
+  'horror-story',    // Monday: "This AI PR would have broken production"
+  'educational',     // Tuesday: Teach a concept (context engineering, gate patterns)
+  'product-demo',    // Wednesday: Specific feature highlight with concrete example
+  'hot-take',        // Thursday: Contrarian opinion about AI coding agents
+  'community',       // Friday: Highlight a user, contributor, or community discussion
+  'tip',             // Saturday: Quick actionable tip
+  'stats',           // Sunday: Weekly build-in-public numbers
+];
+
+function getTodayAngle() {
+  const day = new Date().getUTCDay(); // 0=Sun, 1=Mon, ..., 6=Sat
+  // Remap: Mon=0, Tue=1, ..., Sun=6
+  const idx = day === 0 ? 6 : day - 1;
+  return DAILY_ANGLES[idx];
+}
+
+function generatePost(angle) {
+  const { post, stats } = generateWeeklyStatsPost({ periodDays: 1 });
+  const REPO = 'https://github.com/IgorGanapolsky/ThumbGate';
+
+  switch (angle) {
+    case 'horror-story': {
+      const gate = stats.topGate || 'force-push prevention';
+      return [
+        `A Claude Code agent tried to force-push to main today.`,
+        '',
+        `The "${gate}" gate caught it before execution. No rollback needed, no incident, no Slack panic.`,
+        '',
+        `Pre-action gates > post-mortem reviews.`,
+        '',
+        `ThumbGate is open source: ${REPO}`,
+      ].join('\n');
+    }
+
+    case 'educational':
+      return [
+        'Context engineering vs prompt engineering for AI agents:',
+        '',
+        'Prompt engineering: "Please don\'t force-push to main"',
+        'Context engineering: Agent physically cannot force-push because a gate blocks it',
+        '',
+        'One is a suggestion. The other is enforcement.',
+        '',
+        'The agents that work reliably in production use both — but enforcement is what prevents the 2am incidents.',
+      ].join('\n');
+
+    case 'product-demo':
+      return [
+        'How ThumbGate works in 30 seconds:',
+        '',
+        '1. Agent tries to run a tool call',
+        '2. PreToolUse hook intercepts it',
+        '3. Call is checked against prevention rules',
+        '4. If it matches a known-bad pattern → blocked',
+        '5. Agent tries a different approach',
+        '',
+        'Rules are generated from your thumbs-down feedback. The system learns from your corrections.',
+        '',
+        `Try it: npx thumbgate init`,
+      ].join('\n');
+
+    case 'hot-take':
+      return [
+        'Unpopular opinion: CLAUDE.md files are not enough to make AI agents reliable.',
+        '',
+        'Instructions in markdown are suggestions. The agent can ignore them after context compaction, hallucinate past them, or just decide they don\'t apply.',
+        '',
+        'You need enforcement — gates that physically block bad actions before execution.',
+        '',
+        'Memory helps agents remember. Gates make them comply.',
+      ].join('\n');
+
+    case 'community':
+      return [
+        `This week's most common agent mistake caught by ThumbGate users:`,
+        '',
+        `Agents trying to commit .env files to public repos.`,
+        '',
+        `It's such a common pattern that we made it a default gate. Works across Claude Code, Cursor, and Codex.`,
+        '',
+        `What's the most dangerous thing your AI agent has tried to do? Genuinely curious.`,
+      ].join('\n');
+
+    case 'tip':
+      return [
+        'Quick tip for Claude Code users:',
+        '',
+        'Add a PreToolUse hook that checks for `git push --force` before every Bash call.',
+        '',
+        'One line of prevention saves hours of rollback.',
+        '',
+        `ThumbGate automates this — generates hooks from your feedback: ${REPO}`,
+      ].join('\n');
+
+    case 'stats':
+      return post; // Use the generated weekly stats
+
+    default:
+      return post;
+  }
+}
+
+async function main() {
+  const dryRun = process.argv.includes('--dry-run');
+  const angle = getTodayAngle();
+  const content = generatePost(angle);
+
+  console.log(`[daily-post] Day: ${new Date().toUTCString()}`);
+  console.log(`[daily-post] Angle: ${angle}`);
+  console.log(`[daily-post] Content:\n${content}\n`);
+
+  if (dryRun) {
+    console.log('[daily-post] Dry run — not posting.');
+    return;
+  }
+
+  // Fetch connected accounts, filter to text-friendly platforms (no Reddit, no Instagram)
+  const accounts = await getConnectedAccounts();
+  const textAccounts = accounts
+    .filter(a => TEXT_PLATFORMS.has(a.platform))
+    .map(a => ({ platform: a.platform, accountId: a._id || a.accountId }));
+
+  if (textAccounts.length === 0) {
+    console.error('[daily-post] No text-friendly accounts connected.');
+    process.exit(1);
+  }
+
+  console.log(`[daily-post] Publishing to ${textAccounts.length} platform(s): ${textAccounts.map(a => a.platform).join(', ')}`);
+
+  const result = await publishPost(content, textAccounts);
+  console.log('[daily-post] Result:', JSON.stringify(result, null, 2));
+
+  if (result.platformResults) {
+    for (const pr of result.platformResults) {
+      if (pr.status === 'published') {
+        console.log(`[daily-post] ${pr.platform}: published`);
+      } else {
+        console.error(`[daily-post] ${pr.platform}: ${pr.status} — ${pr.error || 'unknown'}`);
+      }
+    }
+  }
+}
+
+main().catch(err => {
+  console.error('[daily-post] Fatal:', err.message);
+  process.exit(1);
+});