thumbgate 0.9.9

package/scripts/reddit-dm-outreach.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * reddit-dm-outreach.js
+ * Send direct messages to engaged Reddit users via OAuth2 password grant flow.
+ *
+ * Usage:
+ *   node scripts/reddit-dm-outreach.js
+ *
+ * Requires env vars:
+ *   REDDIT_CLIENT_ID
+ *   REDDIT_CLIENT_SECRET
+ *   REDDIT_USERNAME
+ *   REDDIT_PASSWORD
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+// Parse .env credentials line-by-line
+function parseEnv(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const result = {};
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+
+    const key = trimmed.substring(0, eqIdx).trim();
+    const value = trimmed.substring(eqIdx + 1).trim();
+    result[key] = value;
+  }
+
+  return result;
+}
+
+const envPath = path.join(__dirname, '..', '.env');
+const env = parseEnv(envPath);
+
+const REDDIT_CLIENT_ID = env.REDDIT_CLIENT_ID;
+const REDDIT_CLIENT_SECRET = env.REDDIT_CLIENT_SECRET;
+const REDDIT_USERNAME = env.REDDIT_USERNAME;
+const REDDIT_PASSWORD = env.REDDIT_PASSWORD;
+
+if (!REDDIT_CLIENT_ID || !REDDIT_CLIENT_SECRET || !REDDIT_USERNAME || !REDDIT_PASSWORD) {
+  console.error('❌ Missing Reddit credentials in .env');
+  process.exit(1);
+}
+
+console.log('📧 Reddit DM Outreach');
+console.log('---');
+
+// OAuth2 password grant flow
+function authenticate() {
+  return new Promise((resolve, reject) => {
+    const authHeader = 'Basic ' + Buffer.from(
+      REDDIT_CLIENT_ID + ':' + REDDIT_CLIENT_SECRET
+    ).toString('base64');
+
+    const postData = [
+      'grant_type=password',
+      `username=${encodeURIComponent(REDDIT_USERNAME)}`,
+      `password=${encodeURIComponent(REDDIT_PASSWORD)}`,
+      'duration=permanent'
+    ].join('&');
+
+    const authOptions = {
+      hostname: 'www.reddit.com',
+      port: 443,
+      path: '/api/v1/access_token',
+      method: 'POST',
+      headers: {
+        'Authorization': authHeader,
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'User-Agent': 'ThumbGate-Testimonial/1.0',
+        'Content-Length': Buffer.byteLength(postData)
+      }
+    };
+
+    const authReq = https.request(authOptions, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.access_token) {
+            console.log('✅ Authenticated as', REDDIT_USERNAME);
+            resolve(parsed.access_token);
+          } else {
+            reject(new Error('Auth failed: ' + JSON.stringify(parsed)));
+          }
+        } catch (e) {
+          reject(new Error('Parse error: ' + e.message));
+        }
+      });
+    });
+
+    authReq.on('error', reject);
+    authReq.write(postData);
+    authReq.end();
+  });
+}
+
+// Send a single DM
+function sendDM(accessToken, to, subject, text) {
+  return new Promise((resolve, reject) => {
+    const dmData = JSON.stringify({ to, subject, text });
+
+    const dmOptions = {
+      hostname: 'oauth.reddit.com',
+      port: 443,
+      path: '/api/compose',
+      method: 'POST',
+      headers: {
+        'Authorization': 'Bearer ' + accessToken,
+        'Content-Type': 'application/json',
+        'User-Agent': 'ThumbGate-Testimonial/1.0',
+        'Content-Length': Buffer.byteLength(dmData)
+      }
+    };
+
+    const dmReq = https.request(dmOptions, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          resolve();
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 200)}`));
+        }
+      });
+    });
+
+    dmReq.on('error', reject);
+    dmReq.write(dmData);
+    dmReq.end();
+  });
+}
+
+// Main
+async function main() {
+  try {
+    const accessToken = await authenticate();
+
+    const messages = [
+      {
+        to: 'game-of-kton',
+        subject: 'ThumbGate Pro — Try it free, get the hook',
+        text: 'Hey, thanks for the thoughtful comments on the Cursor thread about agent memory. You clearly get the hooks-based enforcement approach. Would you be open to trying ThumbGate Pro for free? I\'d love to get your honest take — if you like it, a one-sentence quote I can use on the landing page would be huge. No strings attached either way. Here\'s the repo: https://github.com/IgorGanapolsky/ThumbGate'
+      },
+      {
+        to: 'Deep_Ad1959',
+        subject: 'ThumbGate Pro — Context-dependent blocking (your idea)',
+        text: 'Hey, your point about context-dependent blocking was spot on — it\'s exactly why we use Thompson Sampling instead of hard binary blocks. Would you be interested in trying ThumbGate Pro for free? If you find it useful, I\'d appreciate a quick testimonial quote for the site. No obligation. Repo: https://github.com/IgorGanapolsky/ThumbGate'
+      }
+    ];
+
+    console.log(`\n📨 Sending ${messages.length} direct messages...\n`);
+
+    for (const msg of messages) {
+      try {
+        await sendDM(accessToken, msg.to, msg.subject, msg.text);
+        console.log(`✅ DM sent to u/${msg.to}`);
+      } catch (err) {
+        console.error(`❌ Failed to send DM to u/${msg.to}:`, err.message);
+      }
+    }
+
+    console.log(`\n✅ Outreach complete (${messages.length}/${messages.length} sent)`);
+  } catch (err) {
+    console.error('❌ Error:', err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/reddit-monitor-cron.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_DIR="/Users/igorganapolsky/workspace/git/igor/rlhf"
+LOG_FILE="${REPO_DIR}/.thumbgate/reddit-monitor.log"
+
+mkdir -p "${REPO_DIR}/.rlhf"
+
+# Load environment
+if [ -f "${REPO_DIR}/.env" ]; then
+  while IFS='=' read -r key value; do
+    # Skip comments and empty lines
+    [[ -z "$key" || "$key" =~ ^# ]] && continue
+    # Strip leading/trailing whitespace from key
+    key=$(echo "$key" | xargs)
+    # Export the variable (value preserved as-is)
+    export "$key=$value"
+  done < "${REPO_DIR}/.env"
+fi
+
+echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] Reddit monitor run starting" >> "$LOG_FILE"
+
+cd "$REPO_DIR"
+/opt/homebrew/bin/node scripts/social-reply-monitor.js >> "$LOG_FILE" 2>&1
+
+echo "[$(date -u +"%Y-%m-%dT%H:%M:%SZ")] Reddit monitor run complete" >> "$LOG_FILE"

package/scripts/reflector-agent.js

@@ -0,0 +1,221 @@
+/**
+ * Reflector Agent — Self-Healing Brain
+ *
+ * On negative feedback, analyzes the conversation window to:
+ * 1. Identify what the assistant did wrong
+ * 2. Check if this is a recurring mistake
+ * 3. Propose a specific, actionable rule
+ * 4. Return the proposal for user confirmation
+ *
+ * This transforms ThumbGate from "Manual Guardrail" to "Self-Healing Brain"
+ */
+
+'use strict';
+
+const { retrieveRelevantLessons } = require('./lesson-retrieval');
+const {
+  extractFilePaths,
+  extractToolCalls,
+  extractErrors,
+  normalizeConversationWindow,
+} = require('./conversation-context');
+
+/**
+ * Run a post-mortem analysis on a negative feedback event.
+ * @param {object} params
+ * @param {Array} params.conversationWindow - Last N conversation turns
+ * @param {string} params.context - One-line context from the caller
+ * @param {string} params.whatWentWrong - What the caller said went wrong
+ * @param {object} params.structuredRule - IF/THEN rule from lesson-inference
+ * @param {object} params.feedbackEvent - The stored feedback event
+ * @returns {object} Reflection result with proposed rule and recurrence info
+ */
+function reflect(params) {
+  const { conversationWindow, context, whatWentWrong, structuredRule, feedbackEvent } = params;
+
+  // 1. Extract what happened from the conversation
+  const analysis = analyzeConversation(conversationWindow || []);
+
+  // 2. Check for recurrence — has this mistake happened before?
+  const recurrence = checkRecurrence(analysis, feedbackEvent);
+
+  // 3. Generate a human-readable proposed rule
+  const proposedRule = generateProposedRule(analysis, structuredRule, recurrence, whatWentWrong);
+
+  // 4. Determine severity based on recurrence
+  const severity = recurrence.count >= 3 ? 'critical' : recurrence.count >= 1 ? 'warning' : 'info';
+
+  return {
+    status: 'reflection_complete',
+    analysis: {
+      userIntent: analysis.userIntent,
+      assistantAction: analysis.assistantAction,
+      errorDetected: analysis.errorDetected,
+      toolsUsed: analysis.toolsUsed,
+      filesInvolved: analysis.filesInvolved,
+    },
+    recurrence: {
+      isRecurring: recurrence.count > 0,
+      count: recurrence.count,
+      previousLessons: recurrence.previousLessons.map(l => ({
+        id: l.id,
+        title: l.title,
+        timestamp: l.timestamp,
+      })),
+    },
+    proposedRule: proposedRule,
+    severity: severity,
+    message: formatReflectionMessage(proposedRule, recurrence, analysis),
+  };
+}
+
+function analyzeConversation(window) {
+  const normalizedWindow = normalizeConversationWindow(window);
+  const userMsgs = normalizedWindow.filter(m => m.role === 'user');
+  const assistantMsgs = normalizedWindow.filter(m => m.role === 'assistant');
+
+  const lastUser = userMsgs[userMsgs.length - 1]?.content || '';
+  const lastAssistant = assistantMsgs[assistantMsgs.length - 1]?.content || '';
+  const corrections = extractCorrections(userMsgs);
+  const toolsUsed = extractToolCalls(normalizedWindow);
+  const filesInvolved = extractFilePaths(normalizedWindow).slice(0, 10);
+  const errors = extractErrors(normalizedWindow).slice(0, 5);
+
+  return {
+    userIntent: lastUser.slice(0, 300),
+    assistantAction: lastAssistant.slice(0, 300),
+    corrections,
+    errorDetected: errors.length > 0,
+    errors,
+    toolsUsed,
+    filesInvolved,
+    messageCount: normalizedWindow.length,
+  };
+}
+
+function checkRecurrence(analysis, feedbackEvent) {
+  // Search existing lessons for similar mistakes
+  let previousLessons = [];
+  try {
+    const context = `${analysis.userIntent} ${analysis.assistantAction} ${analysis.corrections.join(' ')}`;
+    const toolName = analysis.toolsUsed[0] || 'unknown';
+    previousLessons = retrieveRelevantLessons(toolName, context, { maxResults: 5 });
+    // Filter to only negative lessons
+    previousLessons = previousLessons.filter(l => l.signal === 'negative');
+  } catch (_err) {
+    // Non-critical — recurrence check is best-effort
+  }
+
+  return {
+    count: previousLessons.length,
+    previousLessons,
+  };
+}
+
+function generateProposedRule(analysis, structuredRule, recurrence, whatWentWrong) {
+  // Build the most specific rule we can from available data
+  const parts = [];
+
+  // Use corrections from conversation as the strongest signal
+  if (analysis.corrections.length > 0) {
+    const correction = analysis.corrections[0];
+    parts.push({
+      type: 'constraint',
+      rule: `NEVER ${correction}`,
+      source: 'user-correction',
+      confidence: 0.95,
+    });
+  }
+
+  // Use structured rule if available
+  if (structuredRule?.trigger && structuredRule?.action) {
+    parts.push({
+      type: structuredRule.action.type === 'avoid' ? 'constraint' : 'preference',
+      rule: `IF ${structuredRule.trigger.condition} THEN ${structuredRule.action.description}`,
+      source: 'inferred',
+      confidence: structuredRule.confidence || 0.7,
+    });
+  }
+
+  // Use whatWentWrong as fallback
+  if (parts.length === 0 && whatWentWrong) {
+    parts.push({
+      type: 'lesson',
+      rule: `AVOID: ${whatWentWrong}`,
+      source: 'user-provided',
+      confidence: 0.8,
+    });
+  }
+
+  // Use analysis as last resort
+  if (parts.length === 0) {
+    parts.push({
+      type: 'observation',
+      rule: `Review approach when: ${analysis.userIntent.slice(0, 80)}`,
+      source: 'conversation-analysis',
+      confidence: 0.5,
+    });
+  }
+
+  // Pick highest confidence rule
+  const best = parts.sort((a, b) => b.confidence - a.confidence)[0];
+
+  return {
+    ...best,
+    isRecurring: recurrence.count > 0,
+    recurrenceCount: recurrence.count,
+    scope: analysis.filesInvolved.length > 0 ? 'project' : 'global',
+  };
+}
+
+function formatReflectionMessage(proposedRule, recurrence, analysis) {
+  const prefix = recurrence.count > 0
+    ? `I've made this mistake ${recurrence.count + 1} time(s) now. `
+    : '';
+
+  const ruleText = proposedRule.rule;
+
+  const correction = analysis.corrections.length > 0
+    ? ` I noticed you corrected me: "${analysis.corrections[0].slice(0, 80)}".`
+    : '';
+
+  const fileContext = analysis.filesInvolved.length > 0
+    ? ` (in ${analysis.filesInvolved.slice(0, 3).join(', ')})`
+    : '';
+
+  return `${prefix}${correction} I've recorded a rule${fileContext}: "${ruleText}". Correct?`;
+}
+
+function extractCorrections(userMessages) {
+  const results = [];
+  const phraseSets = [
+    ['don\'t ', 'do not ', 'never ', 'stop '],
+    ['wrong ', 'incorrect ', 'that\'s not ', 'no, '],
+    ['i said ', 'i told you ', 'i already '],
+    ['use ', 'switch to ', 'change to '],
+  ];
+
+  for (const message of userMessages) {
+    const content = String(message.content || '').trim();
+    const lower = content.toLowerCase();
+    if (!lower) continue;
+
+    for (const phrases of phraseSets) {
+      for (const phrase of phrases) {
+        const index = lower.indexOf(phrase);
+        if (index === -1) continue;
+        let detail = content.slice(index + phrase.length).trim();
+        const insteadIndex = detail.toLowerCase().indexOf(' instead');
+        if (insteadIndex >= 0) {
+          detail = detail.slice(0, insteadIndex).trim();
+        }
+        if (detail) results.push(detail.slice(0, 100));
+        break;
+      }
+    }
+  }
+
+  return results;
+}
+
+module.exports = { reflect, analyzeConversation, checkRecurrence, generateProposedRule, formatReflectionMessage };

package/scripts/reminder-engine.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const DEFAULT_STATE_PATH = path.join(PROJECT_ROOT, '.rlhf', 'reminder-state.json');
+
+const REMINDER_TEMPLATES = {
+  guardrail_spike: 'Safety guardrails triggered {{count}} times. Re-apply rule: {{rule}}',
+  iteration_limit: 'Approaching max iterations ({{count}}/{{limit}}). Prioritize essential actions only.',
+  tool_misuse: 'Tool misuse detected {{count}} times for: {{tools}}. Verify tool schemas before calling.',
+  error_cascade: 'Repeated errors ({{count}}). Switch strategy: {{suggestion}}',
+};
+
+const DEFAULT_THRESHOLDS = {
+  guardrail_spike: 3,
+  iteration_limit: 1,
+  tool_misuse: 2,
+  error_cascade: 3,
+};
+
+function getStatePath(stateFile) {
+  return stateFile || DEFAULT_STATE_PATH;
+}
+
+function loadState(stateFile) {
+  const p = getStatePath(stateFile);
+  try {
+    if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, 'utf-8'));
+  } catch {
+    // corrupted — start fresh
+  }
+  return { counts: {} };
+}
+
+function saveState(state, stateFile) {
+  const p = getStatePath(stateFile);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(state, null, 2));
+}
+
+/**
+ * Increment the event counter for a given event type.
+ * @param {string} eventType - One of the keys in REMINDER_TEMPLATES
+ * @param {string} [stateFile] - Path to state JSON (default: .thumbgate/reminder-state.json)
+ * @returns {number} New count after incrementing
+ */
+function trackEvent(eventType, stateFile) {
+  const state = loadState(stateFile);
+  state.counts[eventType] = (state.counts[eventType] || 0) + 1;
+  saveState(state, stateFile);
+  return state.counts[eventType];
+}
+
+/**
+ * Get the current event count without modifying state.
+ * @param {string} eventType
+ * @param {string} [stateFile]
+ * @returns {number}
+ */
+function getEventCount(eventType, stateFile) {
+  return loadState(stateFile).counts[eventType] || 0;
+}
+
+/**
+ * Return true if the event count meets or exceeds its threshold.
+ * @param {string} eventType
+ * @param {number} [threshold] - Defaults to DEFAULT_THRESHOLDS[eventType] or 3
+ * @param {string} [stateFile]
+ * @returns {boolean}
+ */
+function shouldInjectReminder(eventType, threshold, stateFile) {
+  const t = typeof threshold === 'number' ? threshold : (DEFAULT_THRESHOLDS[eventType] || 3);
+  return getEventCount(eventType, stateFile) >= t;
+}
+
+/**
+ * Render a reminder template with context variable substitution.
+ * @param {string} eventType
+ * @param {object} ctx - Variables to substitute into {{var}} placeholders
+ * @returns {string}
+ */
+function renderTemplate(eventType, ctx) {
+  const template = REMINDER_TEMPLATES[eventType];
+  if (!template) return `[Reminder] Event: ${eventType}`;
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => (ctx && ctx[key] !== undefined ? ctx[key] : `{${key}}`));
+}
+
+/**
+ * Append a system reminder to a turns array without modifying state.
+ * Callers are responsible for calling trackEvent before/after as needed.
+ * @param {object[]} turns - Existing turns array
+ * @param {string} eventType
+ * @param {object} ctx - Template variables (count will be added automatically)
+ * @param {string} [stateFile]
+ * @returns {object[]} New turns array with reminder appended
+ */
+function injectReminder(turns, eventType, ctx, stateFile) {
+  const count = getEventCount(eventType, stateFile);
+  const message = renderTemplate(eventType, { ...ctx, count });
+  const reminder = {
+    role: 'user',
+    content: `[System Reminder] ${message}`,
+    injectedAt: new Date().toISOString(),
+    eventType,
+  };
+  return [...turns, reminder];
+}
+
+/**
+ * Reset the event counter for a given event type (e.g., after a reminder is acted on).
+ * @param {string} eventType
+ * @param {string} [stateFile]
+ */
+function resetEvent(eventType, stateFile) {
+  const state = loadState(stateFile);
+  state.counts[eventType] = 0;
+  saveState(state, stateFile);
+}
+
+module.exports = {
+  REMINDER_TEMPLATES,
+  DEFAULT_THRESHOLDS,
+  DEFAULT_STATE_PATH,
+  trackEvent,
+  getEventCount,
+  shouldInjectReminder,
+  renderTemplate,
+  injectReminder,
+  resetEvent,
+};