thumbgate 1.4.3 → 1.4.5

package/scripts/social-analytics/post-video.js

@@ -1,316 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * post-video.js
- * Generates a marketing short video and posts it to TikTok, YouTube, and
- * Instagram Reels via Zernio. Tracks everything in the marketing DB to
- * prevent double-posting.
- *
- * Usage:
- *   node scripts/social-analytics/post-video.js
- *   node scripts/social-analytics/post-video.js --campaign=v1.4.1 --dry-run
- *   node scripts/social-analytics/post-video.js --video=/path/to/custom.mp4
- *
- * Required env:
- *   ZERNIO_API_KEY
- * Optional env (overrides hardcoded account IDs):
- *   ZERNIO_TIKTOK_ACCOUNT_ID
- *   ZERNIO_YOUTUBE_ACCOUNT_ID
- *   ZERNIO_INSTAGRAM_ACCOUNT_ID
- */
-
-const { execFileSync, execSync } = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const { loadLocalEnv } = require('./load-env');
-
-loadLocalEnv();
-
-const { hashContent, isDuplicate, record } = require('./db/marketing-db');
-
-// ---------------------------------------------------------------------------
-// Config
-// ---------------------------------------------------------------------------
-
-const ZERNIO_BASE = 'https://zernio.com/api/v1';
-
-const ACCOUNTS = {
-  tiktok:    process.env.ZERNIO_TIKTOK_ACCOUNT_ID    || '69bee0fd6cb7b8cf4c8b2425',
-  youtube:   process.env.ZERNIO_YOUTUBE_ACCOUNT_ID   || '69c14dc36cb7b8cf4c91c1e4',
-  instagram: process.env.ZERNIO_INSTAGRAM_ACCOUNT_ID || '69bed6ad6cb7b8cf4c8b0865',
-};
-
-// Per-platform cooldown in hours — prevents over-posting even when CI fires every 4h
-const PLATFORM_COOLDOWN_HOURS = {
-  tiktok:    4,   // up to 6 videos/day — TikTok rewards frequency
-  instagram: 8,   // up to 3 Reels/day
-  youtube:   12,  // 1-2 Shorts/day
-};
-
-const CAPTIONS = {
-  tiktok: `Your AI agent deleted prod config because it "looked unused" 😬
-
-ThumbGate v1.4.1 intercepts BEFORE the action runs. Checks it against lessons from past failures. Blocks it permanently.
-
-👎 feedback → lesson DB → prevention rule → physical gate
-
-Not a prompt. A block.
-
-npx thumbgate serve — free + open source
-Try the live GPT first: https://chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate
-github.com/IgorGanapolsky/ThumbGate
-
-#ClaudeCode #AIAgents #DevTools #TechTok #Coding #SoftwareDev #AITools #Programming #DevTok`,
-
-  youtube: `ThumbGate v1.4.1: How to stop AI coding agents from repeating mistakes
-
-Your agent force-pushed to main. Deleted prod config. Ran the wrong migration. You told it not to. Next session — same mistake.
-
-ThumbGate solves this with pre-action gates: every 👎 becomes a lesson, every lesson becomes a gate, every gate is enforced via PreToolUse hooks.
-
-v1.4.1: Thompson Sampling · LanceDB vector search · SQLite+FTS5 lesson DB
-
-Live GPT demo: https://chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate
-Free + open source: https://github.com/IgorGanapolsky/ThumbGate
-npx thumbgate serve
-
-#ClaudeCode #AIAgents #DevTools #Shorts`,
-
-  instagram: `AI agent deleted prod config because it "looked unused" 😬
-
-ThumbGate v1.4.1: pre-action safety gates that physically block known-bad patterns before they run.
-
-👎 → lesson DB → prevention rule → blocked forever
-
-Live GPT demo: chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate
-Free + open source. Link in bio 👆
-
-#AIAgents #ClaudeCode #DevTools #Coding #TechTok #SoftwareDev #AITools #MachineLearning #BuildInPublic`,
-};
-
-const YT_TITLE = 'ThumbGate v1.4.1: Stop AI Agents From Repeating Mistakes #shorts';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function parseArgs(argv) {
-  const opts = { dryRun: false, campaign: 'default', videoPath: null, platforms: null, template: 'auto' };
-  for (const arg of argv) {
-    if (arg === '--dry-run') opts.dryRun = true;
-    else if (arg.startsWith('--campaign=')) opts.campaign = arg.slice(11);
-    else if (arg.startsWith('--video=')) opts.videoPath = arg.slice(8);
-    else if (arg.startsWith('--platforms=')) opts.platforms = arg.slice(12).split(',');
-    else if (arg.startsWith('--template=')) opts.template = arg.slice(11);
-  }
-  return opts;
-}
-
-function requireKey() {
-  const k = process.env.ZERNIO_API_KEY;
-  if (!k) throw new Error('ZERNIO_API_KEY env var is required');
-  return k;
-}
-
-async function zernioUpload(apiKey, filePath) {
-  const out = execFileSync('curl', [
-    '-s',
-    '-X', 'POST',
-    `${ZERNIO_BASE}/media`,
-    '-H', `Authorization: Bearer ${apiKey}`,
-    '-F', `files=@${filePath}`,
-  ], { maxBuffer: 10 * 1024 * 1024 }).toString();
-
-  const data = JSON.parse(out);
-  const files = data.files || [];
-  if (!files.length) throw new Error(`Zernio upload failed: ${out}`);
-  return files[0].url;
-}
-
-async function zernioPost(apiKey, { platform, accountId, title, content, mediaUrl, mediaType = 'video' }) {
-  const body = {
-    content,
-    mediaItems: [{ url: mediaUrl, type: mediaType }],
-    platforms: [{ platform, accountId }],
-    publishNow: true,
-  };
-  if (title) body.title = title;
-
-  const out = execFileSync('curl', [
-    '-s',
-    '-X', 'POST',
-    `${ZERNIO_BASE}/posts`,
-    '-H', `Authorization: Bearer ${apiKey}`,
-    '-H', 'Content-Type: application/json',
-    '-d', JSON.stringify(body),
-  ], { maxBuffer: 5 * 1024 * 1024 }).toString();
-
-  return JSON.parse(out);
-}
-
-// ---------------------------------------------------------------------------
-// Video generation
-// ---------------------------------------------------------------------------
-
-function generateVideo(outDir, template = 'auto', campaign = 'default') {
-  const slidesScript = path.join(__dirname, 'generate-slides.js');
-  const concatFile = path.join(outDir, 'concat.txt');
-  const videoOut = path.join(outDir, 'thumbgate-short.mp4');
-
-  console.log('[post-video] Generating slides...');
-  execFileSync(process.execPath, [
-    slidesScript,
-    `--out=${outDir}`,
-    `--template=${template}`,
-    `--campaign=${campaign}`,
-  ], { stdio: 'inherit' });
-
-  // Build ffmpeg concat file from manifest
-  const manifest = JSON.parse(fs.readFileSync(path.join(outDir, 'manifest.json'), 'utf8'));
-  const concatLines = manifest.slides.map(s => `file '${path.join(outDir, s.file)}'\nduration ${s.holdSeconds}`);
-  const lastSlide = manifest.slides[manifest.slides.length - 1];
-  concatLines.push(`file '${path.join(outDir, lastSlide.file)}'`);
-  fs.writeFileSync(concatFile, concatLines.join('\n'));
-
-  console.log('[post-video] Rendering video...');
-  execSync(
-    `ffmpeg -y -f concat -safe 0 -i "${concatFile}" \
-      -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2,setsar=1" \
-      -c:v libx264 -r 30 -pix_fmt yuv420p -movflags +faststart \
-      "${videoOut}"`,
-    { stdio: 'pipe' }
-  );
-
-  const size = (fs.statSync(videoOut).size / 1024).toFixed(0);
-  console.log(`[post-video] Video ready: ${videoOut} (${size} KB, ${manifest.totalDuration}s)`);
-  return videoOut;
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-function prepareVideo(opts) {
-  let videoPath = opts.videoPath;
-  let templateId = opts.template;
-  if (!videoPath) {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-video-'));
-    videoPath = generateVideo(tmpDir, opts.template, opts.campaign);
-    // Read back the chosen template id from manifest
-    try {
-      const manifest = JSON.parse(fs.readFileSync(path.join(tmpDir, 'manifest.json'), 'utf8'));
-      templateId = String(manifest.templateId || opts.template);
-    } catch {}
-  }
-  return { videoPath, templateId };
-}
-
-function buildPlatformPlan(platform, baseHash) {
-  const caption = CAPTIONS[platform];
-  if (!caption) {
-    console.warn(`[post-video] No caption for platform: ${platform} — skipping`);
-    return null;
-  }
-
-  const contentHash = hashContent(`${baseHash}::${platform}`);
-  const cooldownHours = PLATFORM_COOLDOWN_HOURS[platform] || 4;
-  return { platform, caption, contentHash, cooldownDays: cooldownHours / 24 };
-}
-
-function duplicateResult(plan) {
-  const existing = isDuplicate(plan.platform, plan.contentHash, plan.cooldownDays);
-  if (!existing) return null;
-  console.log(`[post-video] SKIP ${plan.platform} — already posted (${existing.published_at}): ${existing.post_url}`);
-  return { platform: plan.platform, status: 'skipped', reason: 'duplicate', existing };
-}
-
-function recordPostOutcome({ plan, status, postUrl, error, campaign, mediaUrl, templateId, response }) {
-  if (status === 'published') {
-    console.log(`[post-video] ✓ ${plan.platform}: ${postUrl}`);
-    record({ type: 'video', platform: plan.platform, contentHash: plan.contentHash, postUrl, campaign,
-      tags: ['v1.4.1', 'short', campaign],
-      extra: { mediaUrl, templateId, zernioPostId: response.post?._id } });
-    return;
-  }
-
-  console.error(`[post-video] ✗ ${plan.platform}: ${error}`);
-  record({ type: 'video', platform: plan.platform, contentHash: plan.contentHash, status: 'failed', campaign,
-    extra: { error } });
-}
-
-async function processPlatform(plan, context) {
-  const duplicate = duplicateResult(plan);
-  if (duplicate) return duplicate;
-
-  if (context.dryRun) {
-    console.log(`[post-video] DRY-RUN ${plan.platform} — would post video`);
-    return { platform: plan.platform, status: 'dry-run' };
-  }
-
-  try {
-    if (!context.mediaUrl) {
-      console.log(`[post-video] Uploading video to Zernio...`);
-      context.mediaUrl = await zernioUpload(context.apiKey, context.videoPath);
-      console.log(`[post-video] Uploaded: ${context.mediaUrl}`);
-    }
-
-    console.log(`[post-video] Posting to ${plan.platform}...`);
-    const response = await zernioPost(context.apiKey, {
-      platform: plan.platform,
-      accountId: ACCOUNTS[plan.platform],
-      title: plan.platform === 'youtube' ? YT_TITLE : undefined,
-      content: plan.caption,
-      mediaUrl: context.mediaUrl,
-    });
-
-    const platformResult = response.post?.platforms?.[0] || {};
-    const status = platformResult.status || 'unknown';
-    const postUrl = platformResult.platformPostUrl || '';
-    const error = platformResult.errorMessage || response.error || '';
-    recordPostOutcome({ plan, status, postUrl, error, campaign: context.campaign,
-      mediaUrl: context.mediaUrl, templateId: context.templateId, response });
-    return { platform: plan.platform, status, postUrl, error };
-  } catch (err) {
-    console.error(`[post-video] ✗ ${plan.platform} error: ${err.message}`);
-    return { platform: plan.platform, status: 'error', error: err.message };
-  }
-}
-
-function statusIcon(status) {
-  if (status === 'published') return '✓';
-  if (['skipped', 'dry-run'].includes(status)) return '→';
-  return '✗';
-}
-
-function printSummary(results) {
-  console.log('\n[post-video] Summary:');
-  for (const r of results) {
-    const icon = statusIcon(r.status);
-    console.log(`  ${icon} ${r.platform}: ${r.status}${r.postUrl ? ' — ' + r.postUrl : ''}${r.error ? ' — ' + r.error : ''}`);
-  }
-}
-
-async function main() {
-  const opts = parseArgs(process.argv.slice(2));
-  const apiKey = opts.dryRun ? null : requireKey();
-  const platforms = opts.platforms || ['tiktok', 'youtube', 'instagram'];
-  console.log(`[post-video] campaign=${opts.campaign} platforms=${platforms.join(',')} dryRun=${opts.dryRun}`);
-
-  const { videoPath, templateId } = prepareVideo(opts);
-  const baseHash = hashContent(`video::template-${templateId}::${opts.campaign}`);
-  const context = { apiKey, campaign: opts.campaign, dryRun: opts.dryRun, mediaUrl: null, templateId, videoPath };
-  const plans = platforms.map(platform => buildPlatformPlan(platform, baseHash)).filter(Boolean);
-  const results = [];
-
-  for (const plan of plans) {
-    results.push(await processPlatform(plan, context));
-  }
-
-  printSummary(results);
-
-  return results;
-}
-
-main().catch(err => { console.error(err.message); process.exit(1); });

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

@@ -1,104 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * publish-instagram-thumbgate.js
- * Complete workflow: generate Instagram card image and post to Instagram via Zernio.
- *
- * Usage:
- *   node publish-instagram-thumbgate.js [--image-only] [--post-only]
- *
- * Options:
- *   --image-only    Generate image only, don't post
- *   --post-only     Post an existing image without regenerating it
- */
-
-const path = require('path');
-const fs = require('node:fs');
-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, '.thumbgate', 'instagram-card.png');
-
-async function publishInstagramThumbGate(options = {}) {
-  const {
-    caption = THUMBGATE_CAPTION,
-    imageOnly = false,
-    postOnly = false,
-    imagePath = IMAGE_PATH,
-    schedule = '',
-    timezone = 'America/New_York',
-    utm,
-  } = options;
-
-  try {
-    // Step 1: Generate image (unless --post-only)
-    if (!postOnly) {
-      console.log('[workflow] Step 1: Generating Instagram card...');
-      const generatedPath = await generateInstagramCard(imagePath);
-      console.log(`[workflow] ✅ Image ready: ${generatedPath}`);
-
-      if (imageOnly) {
-        console.log('[workflow] Image-only mode. Stopping here.');
-        return { imagePath: generatedPath };
-      }
-    } else if (!fs.existsSync(imagePath)) {
-      throw new Error(`Image file is required for --post-only mode: ${imagePath}`);
-    }
-
-    // Step 2: Post to Instagram (unless --image-only)
-    if (!imageOnly) {
-      console.log('[workflow] Step 2: Publishing to Instagram via Zernio...');
-      const postResult = await postThumbGateToInstagram({
-        caption,
-        imagePath,
-        schedule,
-        timezone,
-        utm,
-      });
-      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) {
-    console.error(`[workflow] ❌ Failed: ${err.message}`);
-    throw err;
-  }
-}
-
-// CLI execution
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const imageOnly = args.includes('--image-only');
-  const postOnly = args.includes('--post-only');
-
-  if (imageOnly && postOnly) {
-    console.error('❌ Cannot specify both --image-only and --post-only');
-    process.exit(1);
-  }
-
-  (async () => {
-    try {
-      const result = await publishInstagramThumbGate({ imageOnly, postOnly });
-      console.log('\n✅ Workflow complete!');
-      console.log(JSON.stringify(result, null, 2));
-      process.exit(0);
-    } catch (err) {
-      console.error(`\n❌ Workflow failed: ${err.message}`);
-      process.exit(1);
-    }
-  })();
-}
-
-module.exports = { publishInstagramThumbGate, IMAGE_PATH };