thumbgate 0.9.10 → 0.9.11

package/scripts/rlhf_session_start.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# Best-effort Claude SessionStart hook that bootstraps ThumbGate/Codex support
+# for repos under ~/workspace/git without surfacing noisy hook errors.
+
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+HOOK_INPUT="$(cat 2>/dev/null || true)"
+TARGET_DIR="${CLAUDE_PROJECT_DIR:-}"
+
+if [ -z "${TARGET_DIR}" ] && [ -n "${HOOK_INPUT}" ]; then
+  TARGET_DIR="$(printf '%s' "${HOOK_INPUT}" | /usr/bin/python3 -c 'import json,sys; raw=sys.stdin.read().strip(); print(json.loads(raw).get("cwd","")) if raw else print("")' 2>/dev/null || true)"
+fi
+
+if [ -z "${TARGET_DIR}" ]; then
+  TARGET_DIR="${PWD:-}"
+fi
+
+if [ -z "${TARGET_DIR}" ]; then
+  exit 0
+fi
+
+REPO_ROOT="$(git -C "${TARGET_DIR}" rev-parse --show-toplevel 2>/dev/null || true)"
+WORKSPACE_ROOT="${HOME:-}/workspace/git"
+
+case "${REPO_ROOT}" in
+  "${WORKSPACE_ROOT}"/*) ;;
+  *) exit 0 ;;
+esac
+
+node "${SCRIPT_DIR}/ensure-repo-bootstrap.js" "${REPO_ROOT}" >/dev/null 2>&1 || true
+exit 0

package/scripts/skill-quality-tracker.js

@@ -15,15 +15,13 @@
 const fs = require('fs');
 const readline = require('readline');
 const path = require('path');
-
-const FEEDBACK_DIR = process.env.THUMBGATE_FEEDBACK_DIR
-  || path.join(__dirname, '..', '.claude', 'memory', 'feedback');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 const METRICS_PATH = process.env.METRICS_PATH
-  || path.join(FEEDBACK_DIR, 'tool-metrics.jsonl');
+  || path.join(resolveFeedbackDir(), 'tool-metrics.jsonl');
 
 const FEEDBACK_PATH = process.env.FEEDBACK_PATH
-  || path.join(FEEDBACK_DIR, 'feedback-log.jsonl');
+  || path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
 
 // Correlation window: feedback within 60 seconds of a tool call is considered correlated
 const CORRELATION_WINDOW_MS = 60_000;

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/instagram-thumbgate-post.js

@@ -12,8 +12,9 @@
 const path = require('path');
 const {
   publishPost,
-  publishToAllPlatforms,
+  schedulePost,
   getConnectedAccounts,
+  uploadLocalMedia,
 } = require('./publishers/zernio');
 
 const THUMBGATE_CAPTION = `Your AI coding agent has amnesia. It forgets everything between sessions.
@@ -24,9 +25,14 @@ One command: npx thumbgate init
 
 Works with Claude Code, Cursor, Codex, Gemini.
 
-#AIAgents #DeveloperTools #CodingAgents #MCP #OpenSource #ClaudeCode #ThumbGate`;
+#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';
 
-async function postThumbGateToInstagram() {
   try {
     console.log('[instagram] Fetching Zernio connected accounts...');
     const accounts = await getConnectedAccounts();
@@ -46,10 +52,38 @@ async function postThumbGateToInstagram() {
       },
     ];
 
-    console.log('[instagram] Publishing ThumbGate caption to Instagram...');
-    const result = await publishPost(THUMBGATE_CAPTION, platforms);
+    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);
 
-    console.log('✅ Post published successfully!');
+    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}`);
+    }
+
+    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) {
@@ -60,9 +94,13 @@ async function postThumbGateToInstagram() {
 
 // 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();
+      await postThumbGateToInstagram({ imagePath });
       process.exit(0);
     } catch (err) {
       process.exit(1);

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/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,
+};

package/scripts/social-analytics/poll-all.js

@@ -1,24 +1,9 @@
 'use strict';
 
-require('dotenv').config({ path: require('node:path').resolve(__dirname, '..', '..', '.env') });
 const path = require('node:path');
-const fs = require('node:fs');
-
-// Load .env if available
-const envPath = path.resolve(__dirname, '..', '..', '.env');
-if (fs.existsSync(envPath)) {
-  const envContent = fs.readFileSync(envPath, 'utf8');
-  for (const line of envContent.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eqIdx = trimmed.indexOf('=');
-    if (eqIdx > 0) {
-      const key = trimmed.slice(0, eqIdx);
-      const value = trimmed.slice(eqIdx + 1);
-      if (!process.env[key]) process.env[key] = value;
-    }
-  }
-}
+const { loadLocalEnv } = require('./load-env');
+
+loadLocalEnv({ envPath: path.resolve(__dirname, '..', '..', '.env') });
 
 const { initDb } = require('./store');
 

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

@@ -11,11 +11,14 @@
  */
 
 const { normalizeZernioMetric } = require('../normalizer');
+const { loadLocalEnv } = require('../load-env');
 const { upsertMetric, initDb } = require('../store');
 const { getConnectedAccounts } = require('../publishers/zernio');
 
 const ZERNIO_BASE = 'https://zernio.com/api/v1';
 
+loadLocalEnv();
+
 function requireApiKey() {
   const key = process.env.ZERNIO_API_KEY;
   if (!key) {

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

@@ -10,10 +10,11 @@
  *
  * Options:
  *   --image-only    Generate image only, don't post
- *   --post-only     Post caption only, don't generate image (caption can work without image on Zernio)
+ *   --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');
 
@@ -22,9 +23,13 @@ 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 {
@@ -38,18 +43,32 @@ async function publishInstagramThumbGate(options = {}) {
         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();
-      console.log(`[workflow] ✅ Post published: ${postResult.id || postResult.data?.id}`);
+      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) {