thumbgate 0.9.9

package/scripts/social-analytics/digest.js

@@ -0,0 +1,256 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { initDb, queryMetrics, topContent, getFollowerHistory } = require('./store');
+
+const PLATFORMS = ['instagram', 'tiktok', 'github'];
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DEFAULT_OUTPUT_DIR = path.join(REPO_ROOT, '.artifacts', 'social', 'digests');
+
+/**
+ * Formats a Date to YYYY-MM-DD in local time.
+ * @param {Date} date
+ * @returns {string}
+ */
+function toDateString(date) {
+  return date.toISOString().slice(0, 10);
+}
+
+/**
+ * Calculates the follower delta for each platform over the given window.
+ * Returns the difference between the most recent snapshot and the oldest
+ * snapshot within the window. Returns 0 if fewer than 2 snapshots exist.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {number} days
+ * @returns {{ instagram: number, tiktok: number, github: number }}
+ */
+function buildFollowerDelta(db, days) {
+  const delta = {};
+  for (const platform of PLATFORMS) {
+    const history = getFollowerHistory(db, { platform, days });
+    if (history.length >= 2) {
+      delta[platform] = history[history.length - 1].follower_count - history[0].follower_count;
+    } else if (history.length === 1) {
+      delta[platform] = 0;
+    } else {
+      delta[platform] = 0;
+    }
+  }
+  return delta;
+}
+
+/**
+ * Builds per-platform aggregated metrics map.
+ *
+ * @param {object[]} rows - Rows from queryMetrics (all platforms).
+ * @returns {object}
+ */
+function buildByPlatform(rows) {
+  const byPlatform = {};
+  for (const platform of PLATFORMS) {
+    const row = rows.find((r) => r.platform === platform);
+    if (row) {
+      byPlatform[platform] = {
+        post_count: row.post_count,
+        total_impressions: row.total_impressions,
+        total_reach: row.total_reach,
+        total_likes: row.total_likes,
+        total_comments: row.total_comments,
+        total_shares: row.total_shares,
+        total_saves: row.total_saves,
+        total_clicks: row.total_clicks,
+        total_video_views: row.total_video_views,
+        avg_impressions: row.avg_impressions,
+        avg_likes: row.avg_likes,
+      };
+    } else {
+      byPlatform[platform] = {
+        post_count: 0,
+        total_impressions: 0,
+        total_reach: 0,
+        total_likes: 0,
+        total_comments: 0,
+        total_shares: 0,
+        total_saves: 0,
+        total_clicks: 0,
+        total_video_views: 0,
+        avg_impressions: 0,
+        avg_likes: 0,
+      };
+    }
+  }
+  return byPlatform;
+}
+
+/**
+ * Generates a weekly digest object from the SQLite database.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {{ days?: number }} options
+ * @returns {object} digest
+ */
+function generateDigest(db, { days = 7 } = {}) {
+  const end = new Date();
+  const start = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+  const allMetrics = queryMetrics(db, { days });
+  const top = topContent(db, { days, limit: 10 });
+  const followerDelta = buildFollowerDelta(db, days);
+  const byPlatform = buildByPlatform(allMetrics);
+
+  // Aggregate totals across all platforms.
+  let totalImpressions = 0;
+  let totalLikes = 0;
+  let totalComments = 0;
+  let totalShares = 0;
+
+  for (const row of allMetrics) {
+    totalImpressions += row.total_impressions || 0;
+    totalLikes += row.total_likes || 0;
+    totalComments += row.total_comments || 0;
+    totalShares += row.total_shares || 0;
+  }
+
+  const engagementRaw =
+    totalImpressions > 0
+      ? (((totalLikes + totalComments + totalShares) / totalImpressions) * 100).toFixed(1)
+      : '0.0';
+
+  const topContent_ = top.map((row) => ({
+    platform: row.platform,
+    post_id: row.post_id,
+    post_url: row.post_url || null,
+    total_engagement: row.total_engagement,
+    impressions: row.total_impressions,
+  }));
+
+  return {
+    period: {
+      start: toDateString(start),
+      end: toDateString(end),
+    },
+    summary: {
+      total_impressions: totalImpressions,
+      total_likes: totalLikes,
+      total_comments: totalComments,
+      total_shares: totalShares,
+      engagement_rate: `${engagementRaw}%`,
+      follower_delta: followerDelta,
+    },
+    by_platform: byPlatform,
+    top_content: topContent_,
+  };
+}
+
+/**
+ * Converts a digest object to a readable markdown string.
+ *
+ * @param {object} digest
+ * @returns {string}
+ */
+function renderDigestMarkdown(digest) {
+  const { period, summary, by_platform, top_content } = digest;
+
+  const lines = [];
+
+  lines.push(`# Weekly Social Digest: ${period.start} → ${period.end}`);
+  lines.push('');
+  lines.push('## Summary');
+  lines.push('');
+  lines.push(`| Metric | Value |`);
+  lines.push(`|--------|-------|`);
+  lines.push(`| Total Impressions | ${summary.total_impressions.toLocaleString()} |`);
+  lines.push(`| Total Likes | ${summary.total_likes.toLocaleString()} |`);
+  lines.push(`| Total Comments | ${summary.total_comments.toLocaleString()} |`);
+  lines.push(`| Total Shares | ${summary.total_shares.toLocaleString()} |`);
+  lines.push(`| Engagement Rate | ${summary.engagement_rate} |`);
+  lines.push('');
+  lines.push('### Follower Delta');
+  lines.push('');
+  lines.push(`| Platform | Change |`);
+  lines.push(`|----------|--------|`);
+  for (const [platform, delta] of Object.entries(summary.follower_delta)) {
+    const sign = delta >= 0 ? '+' : '';
+    lines.push(`| ${platform} | ${sign}${delta} |`);
+  }
+
+  lines.push('');
+  lines.push('## By Platform');
+  lines.push('');
+
+  for (const [platform, stats] of Object.entries(by_platform)) {
+    lines.push(`### ${platform.charAt(0).toUpperCase() + platform.slice(1)}`);
+    lines.push('');
+    lines.push(`| Metric | Value |`);
+    lines.push(`|--------|-------|`);
+    lines.push(`| Posts | ${stats.post_count} |`);
+    lines.push(`| Impressions | ${stats.total_impressions.toLocaleString()} |`);
+    lines.push(`| Reach | ${stats.total_reach.toLocaleString()} |`);
+    lines.push(`| Likes | ${stats.total_likes.toLocaleString()} |`);
+    lines.push(`| Comments | ${stats.total_comments.toLocaleString()} |`);
+    lines.push(`| Shares | ${stats.total_shares.toLocaleString()} |`);
+    lines.push(`| Saves | ${stats.total_saves.toLocaleString()} |`);
+    lines.push(`| Clicks | ${stats.total_clicks.toLocaleString()} |`);
+    lines.push(`| Video Views | ${stats.total_video_views.toLocaleString()} |`);
+    lines.push('');
+  }
+
+  lines.push('## Top Content');
+  lines.push('');
+
+  if (top_content.length === 0) {
+    lines.push('_No content recorded in this period._');
+  } else {
+    lines.push(`| # | Platform | Post ID | Engagement | Impressions | URL |`);
+    lines.push(`|---|----------|---------|------------|-------------|-----|`);
+    top_content.forEach((item, idx) => {
+      const url = item.post_url ? `[link](${item.post_url})` : '—';
+      lines.push(
+        `| ${idx + 1} | ${item.platform} | ${item.post_id} | ${item.total_engagement} | ${item.impressions.toLocaleString()} | ${url} |`
+      );
+    });
+  }
+
+  lines.push('');
+  lines.push(`_Generated at ${new Date().toISOString()}_`);
+
+  return lines.join('\n');
+}
+
+/**
+ * Writes digest.json and digest.md to the given output directory.
+ *
+ * @param {object} digest
+ * @param {string} outputDir
+ * @returns {{ jsonPath: string, mdPath: string }}
+ */
+function writeDigest(digest, outputDir) {
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const jsonPath = path.join(outputDir, 'digest.json');
+  const mdPath = path.join(outputDir, 'digest.md');
+
+  fs.writeFileSync(jsonPath, JSON.stringify(digest, null, 2), 'utf8');
+  fs.writeFileSync(mdPath, renderDigestMarkdown(digest), 'utf8');
+
+  return { jsonPath, mdPath };
+}
+
+module.exports = {
+  generateDigest,
+  renderDigestMarkdown,
+  writeDigest,
+};
+
+// Run as main: generate and write a 7-day digest.
+if (require.main === module) {
+  const db = initDb();
+  const digest = generateDigest(db, { days: 7 });
+  const { jsonPath, mdPath } = writeDigest(digest, DEFAULT_OUTPUT_DIR);
+  console.log(`Digest written:\n  JSON: ${jsonPath}\n  MD:   ${mdPath}`);
+  console.log(`\nSummary: ${JSON.stringify(digest.summary, null, 2)}`);
+  db.close();
+}

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

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * generate-instagram-card.js
+ * Creates a 1080x1080 ThumbGate Instagram card using sharp.
+ *
+ * Usage:
+ *   node generate-instagram-card.js [--output=path/to/output.png]
+ *
+ * Output: .thumbgate/instagram-card.png (default)
+ */
+
+const fs = require('fs');
+const path = require('path');
+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');
+
+async function generateInstagramCard(outputPath = DEFAULT_OUTPUT) {
+  const width = 1080;
+  const height = 1080;
+
+  // Create SVG markup for the card
+  const svg = `
+    <svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+      <!-- Background -->
+      <rect width="${width}" height="${height}" fill="#0d1117"/>
+
+      <!-- Main heading -->
+      <text x="${width / 2}" y="400" font-size="72" font-weight="bold" text-anchor="middle" fill="#ffffff" font-family="Arial, sans-serif">
+        Your AI agent
+      </text>
+      <text x="${width / 2}" y="490" font-size="72" font-weight="bold" text-anchor="middle" fill="#ffffff" font-family="Arial, sans-serif">
+        has amnesia.
+      </text>
+
+      <!-- Subheading -->
+      <text x="${width / 2}" y="620" font-size="48" text-anchor="middle" fill="#888888" font-family="Arial, sans-serif">
+        Give it memory that
+      </text>
+      <text x="${width / 2}" y="680" font-size="48" text-anchor="middle" fill="#888888" font-family="Arial, sans-serif">
+        survives restarts.
+      </text>
+
+      <!-- Brand -->
+      <text x="${width / 2}" y="950" font-size="56" font-weight="bold" text-anchor="middle" fill="#00d9ff" font-family="Arial, sans-serif">
+        ThumbGate
+      </text>
+    </svg>
+  `;
+
+  if (!sharp) {
+    throw new Error('sharp is not installed. Run: npm install sharp');
+  }
+
+  try {
+    // Ensure output directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Generate PNG from SVG
+    await sharp(Buffer.from(svg))
+      .png()
+      .toFile(outputPath);
+
+    console.log(`✅ Instagram card generated: ${outputPath}`);
+    console.log(`   Size: 1080x1080 PNG`);
+    console.log(`   File size: ${fs.statSync(outputPath).size} bytes`);
+    return outputPath;
+  } catch (err) {
+    console.error(`❌ Image generation failed: ${err.message}`);
+    throw err;
+  }
+}
+
+// CLI execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const outputArg = args.find((a) => a.startsWith('--output='));
+  const outputPath = outputArg ? outputArg.slice(9) : DEFAULT_OUTPUT;
+
+  (async () => {
+    try {
+      await generateInstagramCard(outputPath);
+      process.exit(0);
+    } catch (err) {
+      process.exit(1);
+    }
+  })();
+}
+
+module.exports = { generateInstagramCard, DEFAULT_OUTPUT };

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

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * instagram-thumbgate-post.js
+ * Posts ThumbGate Instagram card and caption via Zernio API.
+ *
+ * Usage:
+ *   node instagram-thumbgate-post.js [--image-path=path/to/image.png]
+ */
+
+const path = require('path');
+const {
+  publishPost,
+  schedulePost,
+  getConnectedAccounts,
+  uploadLocalMedia,
+} = require('./publishers/zernio');
+
+const THUMBGATE_CAPTION = `Your AI coding agent has amnesia. It forgets everything between sessions.
+
+ThumbGate gives it memory that survives restarts. Thumbs-down a mistake → it becomes a prevention rule → the agent can't repeat it.
+
+One command: npx thumbgate init
+
+Works with Claude Code, Cursor, Codex, Gemini.
+
+#AIAgents #DeveloperTools #ClaudeCode #ThumbGate`;
+
+async function postThumbGateToInstagram(options = {}) {
+  const caption = String(options.caption || THUMBGATE_CAPTION).trim();
+  const imagePath = options.imagePath ? path.resolve(options.imagePath) : '';
+  const schedule = String(options.schedule || '').trim();
+  const timezone = String(options.timezone || 'America/New_York').trim() || 'America/New_York';
+
+  try {
+    console.log('[instagram] Fetching Zernio connected accounts...');
+    const accounts = await getConnectedAccounts();
+
+    // Find Instagram account
+    const instagramAccount = accounts.find((a) => a.platform === 'instagram');
+    if (!instagramAccount) {
+      throw new Error('No Instagram account found in Zernio. Please connect Instagram first.');
+    }
+
+    console.log(`[instagram] Found Instagram account: ${instagramAccount.accountId}`);
+
+    const platforms = [
+      {
+        platform: 'instagram',
+        accountId: instagramAccount.accountId,
+      },
+    ];
+
+    if (!imagePath) {
+      throw new Error('Instagram posts require an imagePath because Zernio requires media content for Instagram posts.');
+    }
+
+    console.log(`[instagram] Uploading Instagram media from ${imagePath}...`);
+    const mediaItem = await uploadLocalMedia(imagePath);
+
+    const publishOptions = {
+      mediaItems: [mediaItem],
+      utm: options.utm,
+    };
+
+    let result;
+    if (schedule) {
+      console.log(`[instagram] Scheduling Instagram post for ${schedule} (${timezone})...`);
+      result = await schedulePost(caption, platforms, schedule, timezone, publishOptions);
+    } else {
+      console.log('[instagram] Publishing ThumbGate caption to Instagram...');
+      result = await publishPost(caption, platforms, publishOptions);
+    }
+    if (result && result.blocked) {
+      const reasons = Array.isArray(result.reasons)
+        ? result.reasons.map((reason) => reason.reason || reason.id || String(reason)).join(', ')
+        : 'quality gate blocked the caption';
+      throw new Error(`Instagram post blocked: ${reasons}`);
+    }
+
+    console.log('✅ Post published successfully!');
+    console.log(`Post ID: ${result.id || result.data?.id || 'unknown'}`);
+    return result;
+  } catch (err) {
+    console.error(`❌ Failed to post to Instagram: ${err.message}`);
+    throw err;
+  }
+}
+
+// CLI execution
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const imageArg = args.find((arg) => arg.startsWith('--image-path='));
+  const imagePath = imageArg ? imageArg.slice('--image-path='.length) : '';
+
+  (async () => {
+    try {
+      await postThumbGateToInstagram({ imagePath });
+      process.exit(0);
+    } catch (err) {
+      process.exit(1);
+    }
+  })();
+}
+
+module.exports = { postThumbGateToInstagram, THUMBGATE_CAPTION };

package/scripts/social-analytics/load-env.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const dotenv = require('dotenv');
+
+const DEFAULT_ENV_PATH = path.resolve(__dirname, '..', '..', '.env');
+
+function resolveEnvPath(envPath = DEFAULT_ENV_PATH) {
+  return path.isAbsolute(envPath) ? envPath : path.resolve(process.cwd(), envPath);
+}
+
+function loadLocalEnv(options = {}) {
+  const resolvedPath = resolveEnvPath(options.envPath);
+  if (!fs.existsSync(resolvedPath)) {
+    return {
+      exists: false,
+      loadedKeys: [],
+      path: resolvedPath,
+    };
+  }
+
+  const parsed = dotenv.parse(fs.readFileSync(resolvedPath, 'utf8'));
+  const loadedKeys = [];
+  const override = options.override === true;
+
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!override && process.env[key] !== undefined) {
+      continue;
+    }
+    process.env[key] = value;
+    loadedKeys.push(key);
+  }
+
+  return {
+    exists: true,
+    loadedKeys,
+    path: resolvedPath,
+  };
+}
+
+module.exports = {
+  DEFAULT_ENV_PATH,
+  loadLocalEnv,
+  resolveEnvPath,
+};