thumbgate 0.9.9 → 0.9.11

package/scripts/social-analytics/engagement-audit.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_REPLY_STATE_PATH = path.join(REPO_ROOT, '.thumbgate', 'reply-monitor-state.json');
+const DEFAULT_DRAFTS_PATH = path.join(REPO_ROOT, '.thumbgate', 'reply-drafts.jsonl');
+const DEFAULT_LAUNCH_ASSETS_PATH = path.join(REPO_ROOT, '.thumbgate', 'social-launch-assets.json');
+const DEFAULT_TIMEZONE = 'America/New_York';
+
+const PLATFORM_CAPABILITIES = {
+  x: 'active_reply_monitor',
+  reddit: 'draft_only_reply_monitor',
+  linkedin: 'comment_intake_blocked_by_api_approval',
+  instagram: 'no_comment_intake_implemented',
+  tiktok: 'no_comment_intake_implemented',
+  youtube: 'no_comment_intake_implemented',
+  devto: 'no_comment_intake_implemented',
+};
+
+function parseArgs(argv = []) {
+  const options = {
+    date: '',
+    timezone: DEFAULT_TIMEZONE,
+    replyStatePath: DEFAULT_REPLY_STATE_PATH,
+    draftsPath: DEFAULT_DRAFTS_PATH,
+    launchAssetsPath: DEFAULT_LAUNCH_ASSETS_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = String(argv[index] || '').trim();
+    if (token.startsWith('--date=')) {
+      options.date = token.slice('--date='.length).trim();
+      continue;
+    }
+    if (token === '--date' && argv[index + 1]) {
+      options.date = String(argv[index + 1]).trim();
+      index += 1;
+      continue;
+    }
+    if (token.startsWith('--timezone=')) {
+      options.timezone = token.slice('--timezone='.length).trim() || DEFAULT_TIMEZONE;
+    }
+  }
+
+  return options;
+}
+
+function readJson(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return fallback;
+    }
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function readJsonl(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+  return fs.readFileSync(filePath, 'utf8')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function formatDateInTimezone(date, timezone = DEFAULT_TIMEZONE) {
+  const formatter = new Intl.DateTimeFormat('en-CA', {
+    timeZone: timezone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  });
+  return formatter.format(new Date(date));
+}
+
+function buildPlatformSummary() {
+  return {
+    checked: 0,
+    replied: 0,
+    drafted: 0,
+    skipped: 0,
+    skippedOwnTweet: 0,
+    skippedNoReplyGenerated: 0,
+    capability: '',
+    ownedLaunchAssets: 0,
+  };
+}
+
+function buildEngagementAudit(options = {}) {
+  const timezone = options.timezone || DEFAULT_TIMEZONE;
+  const targetDate = options.date || formatDateInTimezone(new Date(), timezone);
+  const replyState = readJson(options.replyStatePath || DEFAULT_REPLY_STATE_PATH, { repliedTo: {}, lastCheck: {} });
+  const drafts = readJsonl(options.draftsPath || DEFAULT_DRAFTS_PATH);
+  const launchAssets = readJson(options.launchAssetsPath || DEFAULT_LAUNCH_ASSETS_PATH, { launchPosts: {}, campaignPosts: {} });
+
+  const platforms = {
+    x: buildPlatformSummary(),
+    reddit: buildPlatformSummary(),
+    linkedin: buildPlatformSummary(),
+    instagram: buildPlatformSummary(),
+    tiktok: buildPlatformSummary(),
+    youtube: buildPlatformSummary(),
+    devto: buildPlatformSummary(),
+  };
+
+  for (const [platform, capability] of Object.entries(PLATFORM_CAPABILITIES)) {
+    platforms[platform].capability = capability;
+  }
+
+  for (const entry of Object.values(replyState.repliedTo || {})) {
+    const platform = String(entry.platform || '').trim().toLowerCase();
+    if (!platforms[platform]) continue;
+    if (formatDateInTimezone(entry.at, timezone) !== targetDate) continue;
+    platforms[platform].checked += 1;
+    if (entry.drafted) {
+      platforms[platform].drafted += 1;
+      continue;
+    }
+    if (entry.skipped) {
+      platforms[platform].skipped += 1;
+      if (entry.skipped === 'own_tweet') {
+        platforms[platform].skippedOwnTweet += 1;
+      }
+      if (entry.skipped === 'no_reply_generated') {
+        platforms[platform].skippedNoReplyGenerated += 1;
+      }
+      continue;
+    }
+    platforms[platform].replied += 1;
+  }
+
+  for (const draft of drafts) {
+    const platform = String(draft.platform || '').trim().toLowerCase();
+    if (!platforms[platform]) continue;
+    if (formatDateInTimezone(draft.draftedAt, timezone) !== targetDate) continue;
+    platforms[platform].drafted += 1;
+  }
+
+  for (const platform of Object.keys(launchAssets.launchPosts || {})) {
+    if (platforms[platform]) {
+      platforms[platform].ownedLaunchAssets += 1;
+    }
+  }
+  for (const byPlatform of Object.values(launchAssets.campaignPosts || {})) {
+    for (const platform of Object.keys(byPlatform || {})) {
+      if (platforms[platform]) {
+        platforms[platform].ownedLaunchAssets += 1;
+      }
+    }
+  }
+
+  const totals = Object.values(platforms).reduce((acc, platform) => {
+    acc.checked += platform.checked;
+    acc.replied += platform.replied;
+    acc.drafted += platform.drafted;
+    acc.skipped += platform.skipped;
+    return acc;
+  }, { checked: 0, replied: 0, drafted: 0, skipped: 0 });
+
+  return {
+    date: targetDate,
+    timezone,
+    totals,
+    platforms,
+    evidence: {
+      replyStatePath: options.replyStatePath || DEFAULT_REPLY_STATE_PATH,
+      draftsPath: options.draftsPath || DEFAULT_DRAFTS_PATH,
+      launchAssetsPath: options.launchAssetsPath || DEFAULT_LAUNCH_ASSETS_PATH,
+    },
+  };
+}
+
+if (require.main === module) {
+  const audit = buildEngagementAudit(parseArgs(process.argv.slice(2)));
+  process.stdout.write(`${JSON.stringify(audit, null, 2)}\n`);
+}
+
+module.exports = {
+  DEFAULT_DRAFTS_PATH,
+  DEFAULT_LAUNCH_ASSETS_PATH,
+  DEFAULT_REPLY_STATE_PATH,
+  DEFAULT_TIMEZONE,
+  PLATFORM_CAPABILITIES,
+  buildEngagementAudit,
+  formatDateInTimezone,
+  parseArgs,
+  readJsonl,
+};

package/scripts/social-analytics/generate-instagram-card.js

@@ -17,7 +17,7 @@ let sharp;
 try { sharp = require('sharp'); } catch { /* optional dependency */ }
 
 const REPO_ROOT = path.resolve(__dirname, '../..');
-const DEFAULT_OUTPUT = path.join(REPO_ROOT, '.rlhf', 'instagram-card.png');
+const DEFAULT_OUTPUT = path.join(REPO_ROOT, '.thumbgate', 'instagram-card.png');
 
 async function generateInstagramCard(outputPath = DEFAULT_OUTPUT) {
   const width = 1080;

package/scripts/social-analytics/instagram-thumbgate-post.js

@@ -79,7 +79,11 @@ async function postThumbGateToInstagram(options = {}) {
       throw new Error(`Instagram post blocked: ${reasons}`);
     }
 
-    console.log('✅ Post published successfully!');
+    if (schedule) {
+      console.log('✅ Instagram post scheduled successfully!');
+    } else {
+      console.log('✅ Post published successfully!');
+    }
     console.log(`Post ID: ${result.id || result.data?.id || 'unknown'}`);
     return result;
   } catch (err) {

package/scripts/social-analytics/install-growth-automation.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const scheduleManager = require('../schedule-manager');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const GROWTH_REPORT_DIR = path.join(REPO_ROOT, '.thumbgate', 'reports', 'gtm-revenue-loop');
+
+function buildNodeEvalCommand(scriptPath, args = []) {
+  const absolutePath = path.resolve(scriptPath);
+  const serializedArgs = JSON.stringify(args);
+  return [
+    'const { spawnSync } = require(\'node:child_process\');',
+    `process.chdir(${JSON.stringify(REPO_ROOT)});`,
+    `const result = spawnSync(process.execPath, [${JSON.stringify(absolutePath)}, ...${serializedArgs}], {`,
+    '  cwd: process.cwd(),',
+    '  env: process.env,',
+    '  stdio: \'inherit\',',
+    '});',
+    'if (result.error) throw result.error;',
+    'process.exit(typeof result.status === \'number\' ? result.status : 0);',
+  ].join(' ');
+}
+
+function buildGrowthSchedules() {
+  return [
+    {
+      id: 'thumbgate-growth-schedule-campaign',
+      name: 'ThumbGate Growth Campaign Scheduler',
+      description: 'Schedules the next day of tracked Zernio launch posts.',
+      schedule: 'daily 21:15',
+      command: buildNodeEvalCommand(path.join(__dirname, 'schedule-thumbgate-campaign.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-poll-zernio',
+      name: 'ThumbGate Growth Poll Zernio',
+      description: 'Polls Zernio analytics into the local engagement store every hour.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(__dirname, 'pollers', 'zernio.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-sync-launch-assets',
+      name: 'ThumbGate Growth Sync Launch Assets',
+      description: 'Syncs published and scheduled launch assets from Zernio into a durable local registry.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(__dirname, 'sync-launch-assets.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-reply-monitor',
+      name: 'ThumbGate Growth Reply Monitor',
+      description: 'Checks social replies and posts supported follow-ups or drafts them for review.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(REPO_ROOT, 'scripts', 'social-reply-monitor.js')),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-money-watch',
+      name: 'ThumbGate Growth Money Watch',
+      description: 'Persists hourly commercial-change checks so the first paid event is captured immediately.',
+      schedule: 'hourly',
+      command: buildNodeEvalCommand(path.join(REPO_ROOT, 'scripts', 'money-watcher.js'), [
+        '--once',
+      ]),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-revenue-loop',
+      name: 'ThumbGate Growth Revenue Loop',
+      description: 'Refreshes the local-first target queue and outreach artifact for the first paid customers.',
+      schedule: 'daily 08:20',
+      command: buildNodeEvalCommand(path.join(REPO_ROOT, 'scripts', 'autonomous-sales-agent.js'), [
+        `--report-dir=${GROWTH_REPORT_DIR}`,
+        '--max-targets=8',
+      ]),
+      workingDirectory: REPO_ROOT,
+    },
+    {
+      id: 'thumbgate-growth-social-digest',
+      name: 'ThumbGate Growth Social Digest',
+      description: 'Builds the daily social analytics digest after the day closes.',
+      schedule: 'daily 22:15',
+      command: buildNodeEvalCommand(path.join(__dirname, 'run-digest.js'), ['--days=7']),
+      workingDirectory: REPO_ROOT,
+    },
+  ];
+}
+
+function installGrowthAutomation(manager = scheduleManager) {
+  const schedules = buildGrowthSchedules();
+
+  const installed = schedules.map((schedule) => manager.createSchedule(schedule));
+  return {
+    installed,
+    schedules: manager.listSchedules().filter((schedule) => schedule.id.startsWith('thumbgate-growth-')),
+  };
+}
+
+if (require.main === module) {
+  const result = installGrowthAutomation();
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  if (result.installed.some((entry) => !entry.success)) {
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  buildNodeEvalCommand,
+  buildGrowthSchedules,
+  installGrowthAutomation,
+};

package/scripts/social-analytics/publish-instagram-thumbgate.js

@@ -19,7 +19,7 @@ const { generateInstagramCard } = require('./generate-instagram-card');
 const { postThumbGateToInstagram, THUMBGATE_CAPTION } = require('./instagram-thumbgate-post');
 
 const REPO_ROOT = path.resolve(__dirname, '../..');
-const IMAGE_PATH = path.join(REPO_ROOT, '.rlhf', 'instagram-card.png');
+const IMAGE_PATH = path.join(REPO_ROOT, '.thumbgate', 'instagram-card.png');
 
 async function publishInstagramThumbGate(options = {}) {
   const {
@@ -57,12 +57,18 @@ async function publishInstagramThumbGate(options = {}) {
         timezone,
         utm,
       });
-      console.log(`[workflow] ✅ Post published: ${postResult.id || postResult.data?.id}`);
+      if (schedule) {
+        console.log(`[workflow] ✅ Post scheduled: ${postResult.id || postResult.data?.id}`);
+      } else {
+        console.log(`[workflow] ✅ Post published: ${postResult.id || postResult.data?.id}`);
+      }
 
       return {
         success: true,
         imagePath: postOnly ? undefined : imagePath,
         postId: postResult.id || postResult.data?.id,
+        scheduled: Boolean(schedule),
+        scheduledFor: schedule || undefined,
       };
     }
   } catch (err) {

package/scripts/social-analytics/publish-thumbgate-launch.js

@@ -142,7 +142,7 @@ function buildCampaignEntries() {
         linkedin: [
           'Workflow hardening beats generic AI hype.',
           'ThumbGate captures failure signals, promotes them into prevention rules, and blocks the same bad pattern before the next tool call executes.',
-          'This is about one workflow becoming safe enough to ship, not abstract “agent memory.”',
+          'This is about one workflow becoming safe enough to ship, not abstract "agent memory."',
           buildLandingUrl('linkedin', 'campaign_proof_pack'),
         ].join(' '),
         instagram: `${THUMBGATE_CAPTION}\n\nProof-backed workflow hardening.\n\n${buildLandingUrl('instagram', 'campaign_proof_pack')}`,

package/scripts/social-analytics/publishers/reddit.js

@@ -257,24 +257,19 @@ async function submitComment(token, userAgent, { parentId, text }) {
 // ---------------------------------------------------------------------------
 
 /**
- * Build the standard follow-up comment for a Reddit post.
- * This comment contains the trial CTA and source code link.
+ * Build a follow-up comment for a Reddit post.
+ * Kept minimal and non-promotional to avoid spam flags.
+ * Reddit communities aggressively downvote/ban promotional CTAs.
  *
- * @param {string} subreddit - The subreddit name (used for UTM tracking)
- * @param {string} [utmContent] - Optional UTM content tag (defaults to subreddit name)
+ * @param {string} subreddit - The subreddit name
+ * @param {string} [utmContent] - Optional UTM content tag
  * @returns {string} The follow-up comment text
  */
 function buildFollowUpComment(subreddit, utmContent) {
-  const content = utmContent || `${subreddit}_post`;
-  const trialUrl = `https://thumbgate-production.up.railway.app/?utm_source=reddit&utm_medium=organic_social&utm_campaign=reddit_followup_comment&utm_content=${encodeURIComponent(content)}&community=${encodeURIComponent(subreddit)}`;
   return [
-    'The problem: AI coding agents repeat the same mistakes every session. You correct a force-push, it does it again tomorrow. Prompt rules get ignored after context compaction.',
+    'Happy to answer questions about the implementation.',
     '',
-    'ThumbGate fixes this with enforcement, not memory. You give a thumbs-down, it auto-generates a prevention rule, and a gate physically blocks the agent from repeating that action. Thumbs-up reinforces good behavior.',
-    '',
-    `Try free for 7 days (no credit card, 2-minute setup): ${trialUrl}`,
-    '',
-    'Source code (MIT licensed): https://github.com/IgorGanapolsky/ThumbGate',
+    'Source code (MIT): https://github.com/IgorGanapolsky/ThumbGate',
     '',
     'Disclosure: I built this.',
   ].join('\n');

package/scripts/social-analytics/publishers/zernio.js

@@ -129,6 +129,23 @@ async function zernioFetch(method, endpoint, body = null) {
   return res.json();
 }
 
+async function listPosts(options = {}) {
+  const query = new URLSearchParams();
+  if (options.limit) query.set('limit', String(options.limit));
+  if (options.page) query.set('page', String(options.page));
+  if (options.status) query.set('status', String(options.status));
+
+  const suffix = query.toString() ? `?${query.toString()}` : '';
+  const json = await zernioFetch('GET', `/posts${suffix}`);
+  return Array.isArray(json.posts) ? json.posts : (json.data?.posts || json.data || []);
+}
+
+async function deletePost(postId) {
+  if (!postId) throw new Error('deletePost: postId is required');
+  const json = await zernioFetch('DELETE', `/posts/${encodeURIComponent(String(postId).trim())}`);
+  return json.data ?? json;
+}
+
 async function requestMediaPresign(filename, contentType, size) {
   if (!filename) throw new Error('requestMediaPresign: filename is required');
   if (!contentType) throw new Error('requestMediaPresign: contentType is required');
@@ -326,6 +343,8 @@ async function publishToAllPlatforms(content, options = {}) {
 }
 
 module.exports = {
+  deletePost,
+  listPosts,
   publishPost,
   schedulePost,
   publishToAllPlatforms,

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

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+'use strict';
+
+const {
+  buildCampaignEntries,
+  defaultCampaignSchedule,
+} = require('./publish-thumbgate-launch');
+const {
+  deletePost,
+  listPosts,
+} = require('./publishers/zernio');
+const {
+  buildScheduleKey,
+  DEFAULT_STATE_PATH,
+  writeScheduleState,
+} = require('./schedule-thumbgate-campaign');
+
+const CAMPAIGN_MARKERS = {
+  proof_pack: 'campaign_proof_pack',
+  free_local: 'campaign_free_local',
+  checkout_path: 'campaign_checkout_path',
+};
+
+function parseArgs(argv = []) {
+  const options = {
+    cancelDuplicates: false,
+    limit: 50,
+    scheduleTimes: [],
+    statePath: DEFAULT_STATE_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--cancel-duplicates') {
+      options.cancelDuplicates = true;
+      continue;
+    }
+    if (token.startsWith('--limit=')) {
+      options.limit = Number(token.slice('--limit='.length)) || options.limit;
+      continue;
+    }
+    if (token.startsWith('--times=')) {
+      options.scheduleTimes = token.slice('--times='.length).split(',').map((value) => value.trim()).filter(Boolean);
+      continue;
+    }
+    if (token.startsWith('--state-path=')) {
+      options.statePath = token.slice('--state-path='.length).trim() || DEFAULT_STATE_PATH;
+    }
+  }
+
+  return options;
+}
+
+function normalizePlatform(post) {
+  return String(post?.platforms?.[0]?.platform || '').trim().toLowerCase();
+}
+
+function selectCanonicalPost(posts = []) {
+  return [...posts].sort((left, right) => {
+    const leftCreated = new Date(left.createdAt || 0).getTime();
+    const rightCreated = new Date(right.createdAt || 0).getTime();
+    return leftCreated - rightCreated;
+  })[0] || null;
+}
+
+async function reconcileCampaignState(options = {}, api = {}) {
+  const zernio = {
+    deletePost: api.deletePost || deletePost,
+    listPosts: api.listPosts || listPosts,
+  };
+  const scheduleTimes = options.scheduleTimes && options.scheduleTimes.length > 0
+    ? options.scheduleTimes
+    : defaultCampaignSchedule();
+  const posts = await zernio.listPosts({ limit: options.limit || 50 });
+  const scheduled = {};
+  const duplicates = [];
+  const kept = [];
+  const entries = buildCampaignEntries();
+
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    const scheduleLocal = scheduleTimes[index];
+    if (!scheduleLocal) {
+      continue;
+    }
+
+    const scheduledForUtc = new Date(scheduleLocal).toISOString();
+
+    for (const platform of Object.keys(entry.posts)) {
+      const marker = CAMPAIGN_MARKERS[entry.slug];
+      const matchingPosts = posts.filter((post) => (
+        post.status === 'scheduled' &&
+        normalizePlatform(post) === platform &&
+        String(post.content || '').includes(`utm_content=${marker}`) &&
+        String(post.scheduledFor || '') === scheduledForUtc
+      ));
+
+      if (matchingPosts.length === 0) {
+        continue;
+      }
+
+      const canonical = selectCanonicalPost(matchingPosts);
+      if (!canonical) {
+        continue;
+      }
+
+      const scheduleKey = buildScheduleKey({
+        slug: entry.slug,
+        platform,
+        scheduledFor: scheduleLocal,
+      });
+      scheduled[scheduleKey] = {
+        id: canonical._id,
+        scheduledFor: scheduleLocal,
+        slug: entry.slug,
+        platform,
+        recordedAt: new Date().toISOString(),
+      };
+      kept.push({
+        key: scheduleKey,
+        id: canonical._id,
+      });
+
+      const extras = matchingPosts.filter((post) => post._id !== canonical._id);
+      for (const duplicate of extras) {
+        const duplicateRecord = {
+          key: scheduleKey,
+          id: duplicate._id,
+          platform,
+          slug: entry.slug,
+        };
+        if (options.cancelDuplicates) {
+          duplicateRecord.cancelled = await zernio.deletePost(duplicate._id);
+        }
+        duplicates.push(duplicateRecord);
+      }
+    }
+  }
+
+  writeScheduleState(options.statePath || DEFAULT_STATE_PATH, { scheduled });
+  return {
+    duplicates,
+    kept,
+    statePath: options.statePath || DEFAULT_STATE_PATH,
+  };
+}
+
+if (require.main === module) {
+  reconcileCampaignState(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,
+  normalizePlatform,
+  parseArgs,
+  reconcileCampaignState,
+  selectCanonicalPost,
+};