thumbgate 0.9.9

package/scripts/verify-run.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const { appendWorkflowRun } = require('./workflow-runs');
+
+function npmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function buildVerifyPlan(mode = 'quick') {
+  if (mode === 'quick') {
+    return [
+      { command: 'node', args: ['--test', 'tests/verify-run.test.js'] },
+      { command: npmCommand(), args: ['run', 'test:cli'] },
+    ];
+  }
+
+  if (mode === 'full') {
+    return [
+      { command: npmCommand(), args: ['test'] },
+      { command: npmCommand(), args: ['run', 'test:coverage'] },
+      { command: npmCommand(), args: ['run', 'prove:adapters'] },
+      { command: npmCommand(), args: ['run', 'prove:automation'] },
+      { command: npmCommand(), args: ['run', 'prove:claim-verification'] },
+      { command: npmCommand(), args: ['run', 'prove:cloudflare-sandbox'] },
+      { command: npmCommand(), args: ['run', 'prove:data-pipeline'] },
+      { command: npmCommand(), args: ['run', 'prove:evolution'] },
+      { command: npmCommand(), args: ['run', 'prove:harnesses'] },
+      { command: npmCommand(), args: ['run', 'prove:local-intelligence'] },
+      { command: npmCommand(), args: ['run', 'prove:predictive-insights'] },
+      { command: npmCommand(), args: ['run', 'prove:runtime'] },
+      { command: npmCommand(), args: ['run', 'prove:settings'] },
+      { command: npmCommand(), args: ['run', 'prove:seo-gsd'] },
+      { command: npmCommand(), args: ['run', 'prove:tessl'] },
+      { command: npmCommand(), args: ['run', 'prove:xmemory'] },
+      { command: npmCommand(), args: ['run', 'self-heal:check'] },
+    ];
+  }
+
+  throw new Error(`Unsupported verify mode: ${mode}`);
+}
+
+function runPlan(plan, env = process.env, cwd = process.cwd()) {
+  for (const step of plan) {
+    console.log(`$ ${step.command} ${step.args.join(' ')}`.trim());
+    const result = spawnSync(step.command, step.args, {
+      cwd,
+      env,
+      stdio: 'inherit',
+    });
+
+    if (result.status !== 0) {
+      const joined = [step.command, ...step.args].join(' ');
+      throw new Error(`Verification failed: ${joined}`);
+    }
+  }
+}
+
+function copyArtifactIfPresent(sourcePath, targetPath) {
+  if (!fs.existsSync(sourcePath)) {
+    return false;
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+  return true;
+}
+
+function materializeProofArtifacts(tempRoot, cwd = process.cwd()) {
+  const artifacts = [
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'report.json'),
+      target: path.join(cwd, 'proof', 'compatibility', 'report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'report.md'),
+      target: path.join(cwd, 'proof', 'compatibility', 'report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-automation', 'report.json'),
+      target: path.join(cwd, 'proof', 'automation', 'report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-automation', 'report.md'),
+      target: path.join(cwd, 'proof', 'automation', 'report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'cloudflare-sandbox-report.json'),
+      target: path.join(cwd, 'proof', 'cloudflare-sandbox-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'cloudflare-sandbox-report.md'),
+      target: path.join(cwd, 'proof', 'cloudflare-sandbox-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'claim-verification-report.json'),
+      target: path.join(cwd, 'proof', 'claim-verification-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'claim-verification-report.md'),
+      target: path.join(cwd, 'proof', 'claim-verification-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'data-pipeline-report.json'),
+      target: path.join(cwd, 'proof', 'data-pipeline-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'data-pipeline-report.md'),
+      target: path.join(cwd, 'proof', 'data-pipeline-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'evolution-report.json'),
+      target: path.join(cwd, 'proof', 'evolution-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'evolution-report.md'),
+      target: path.join(cwd, 'proof', 'evolution-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-harnesses', 'harnesses-report.json'),
+      target: path.join(cwd, 'proof', 'harnesses-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-harnesses', 'harnesses-report.md'),
+      target: path.join(cwd, 'proof', 'harnesses-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'local-intelligence-report.json'),
+      target: path.join(cwd, 'proof', 'local-intelligence-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'local-intelligence-report.md'),
+      target: path.join(cwd, 'proof', 'local-intelligence-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'predictive-insights-report.json'),
+      target: path.join(cwd, 'proof', 'predictive-insights-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'predictive-insights-report.md'),
+      target: path.join(cwd, 'proof', 'predictive-insights-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-runtime', 'runtime-report.json'),
+      target: path.join(cwd, 'proof', 'runtime-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-runtime', 'runtime-report.md'),
+      target: path.join(cwd, 'proof', 'runtime-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-settings', 'settings-report.json'),
+      target: path.join(cwd, 'proof', 'settings-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-settings', 'settings-report.md'),
+      target: path.join(cwd, 'proof', 'settings-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'seo-gsd-report.json'),
+      target: path.join(cwd, 'proof', 'seo-gsd-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'seo-gsd-report.md'),
+      target: path.join(cwd, 'proof', 'seo-gsd-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'tessl-report.json'),
+      target: path.join(cwd, 'proof', 'tessl-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'tessl-report.md'),
+      target: path.join(cwd, 'proof', 'tessl-report.md'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'xmemory-report.json'),
+      target: path.join(cwd, 'proof', 'xmemory-report.json'),
+    },
+    {
+      source: path.join(tempRoot, 'proof-adapters', 'xmemory-report.md'),
+      target: path.join(cwd, 'proof', 'xmemory-report.md'),
+    },
+  ];
+
+  return artifacts
+    .filter(({ source, target }) => copyArtifactIfPresent(source, target))
+    .map(({ target }) => target);
+}
+
+function recordVerifyWorkflowRun(mode = 'quick', cwd = process.cwd(), feedbackDir = undefined) {
+  if (mode !== 'full') return null;
+  return appendWorkflowRun({
+    workflowId: 'repo_self_dogfood_full_verify',
+    workflowName: 'Repo self dogfood full verification',
+    owner: 'cto',
+    runtime: 'node',
+    status: 'passed',
+    customerType: 'internal_dogfood',
+    teamId: 'internal_repo',
+    reviewed: true,
+    reviewedBy: 'automation',
+    proofBacked: true,
+    source: 'verify:full',
+    proofArtifacts: [
+      path.join(cwd, 'docs', 'VERIFICATION_EVIDENCE.md'),
+      path.join(cwd, 'proof', 'compatibility', 'report.json'),
+      path.join(cwd, 'proof', 'automation', 'report.json'),
+      path.join(cwd, 'proof', 'cloudflare-sandbox-report.json'),
+      path.join(cwd, 'proof', 'claim-verification-report.json'),
+      path.join(cwd, 'proof', 'data-pipeline-report.json'),
+      path.join(cwd, 'proof', 'evolution-report.json'),
+      path.join(cwd, 'proof', 'harnesses-report.json'),
+      path.join(cwd, 'proof', 'local-intelligence-report.json'),
+      path.join(cwd, 'proof', 'predictive-insights-report.json'),
+      path.join(cwd, 'proof', 'runtime-report.json'),
+      path.join(cwd, 'proof', 'settings-report.json'),
+      path.join(cwd, 'proof', 'seo-gsd-report.json'),
+      path.join(cwd, 'proof', 'tessl-report.json'),
+      path.join(cwd, 'proof', 'xmemory-report.json'),
+    ],
+    metadata: {
+      suite: 'repo_verify_full',
+    },
+  }, feedbackDir);
+}
+
+function runVerify(mode = 'quick', baseEnv = process.env, cwd = process.cwd()) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'rlhf-verify-'));
+  const env = {
+    ...baseEnv,
+    THUMBGATE_PROOF_DIR: path.join(tempRoot, 'proof-adapters'),
+    THUMBGATE_AUTOMATION_PROOF_DIR: path.join(tempRoot, 'proof-automation'),
+    THUMBGATE_HARNESSES_PROOF_DIR: path.join(tempRoot, 'proof-harnesses'),
+    THUMBGATE_RUNTIME_PROOF_DIR: path.join(tempRoot, 'proof-runtime'),
+    THUMBGATE_SETTINGS_PROOF_DIR: path.join(tempRoot, 'proof-settings'),
+  };
+
+  runPlan(buildVerifyPlan(mode), env, cwd);
+  materializeProofArtifacts(tempRoot, cwd);
+  const workflowRun = recordVerifyWorkflowRun(mode, cwd);
+
+  return {
+    mode,
+    tempRoot,
+    workflowRun,
+  };
+}
+
+if (require.main === module) {
+  try {
+    runVerify(process.argv[2] || 'quick');
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  buildVerifyPlan,
+  materializeProofArtifacts,
+  recordVerifyWorkflowRun,
+  runPlan,
+  runVerify,
+};

package/scripts/webhook-delivery.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+'use strict';
+
+const https = require('https');
+const http = require('http');
+
+function sendWebhook(webhookUrl, payload) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(webhookUrl);
+    const mod = url.protocol === 'https:' ? https : http;
+    const body = JSON.stringify(payload);
+    
+    const req = mod.request(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      timeout: 10000,
+    }, (res) => {
+      let data = '';
+      res.on('data', (c) => { data += c; });
+      res.on('end', () => resolve({ status: res.statusCode, body: data }));
+    });
+    
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Webhook timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+async function deliverToTeams(webhookUrl, title, message) {
+  return sendWebhook(webhookUrl, {
+    '@type': 'MessageCard',
+    '@context': 'http://schema.org/extensions',
+    summary: title,
+    themeColor: '0076D7',
+    title,
+    text: message,
+  });
+}
+
+async function deliverToSlack(webhookUrl, title, message) {
+  return sendWebhook(webhookUrl, {
+    text: `*${title}*\n${message}`,
+  });
+}
+
+async function deliverToDiscord(webhookUrl, title, message) {
+  return sendWebhook(webhookUrl, {
+    embeds: [{ title, description: message.substring(0, 4096), color: 0x0076D7 }],
+  });
+}
+
+async function deliver(platform, webhookUrl, title, message) {
+  switch (platform) {
+    case 'teams': return deliverToTeams(webhookUrl, title, message);
+    case 'slack': return deliverToSlack(webhookUrl, title, message);
+    case 'discord': return deliverToDiscord(webhookUrl, title, message);
+    default: return sendWebhook(webhookUrl, { title, message });
+  }
+}
+
+module.exports = { deliver, deliverToTeams, deliverToSlack, deliverToDiscord, sendWebhook };

package/scripts/weekly-auto-post.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Weekly Auto-Post — build-in-public experiment loop.
+ *
+ * Every week, auto-generates a social post from ThumbGate stats
+ * ("X mistakes blocked, Y hours saved") and posts to configured platforms.
+ * Closes the deploy → measure → share → compound loop.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { generateWeeklyStatsPost } = require('./daily-digest');
+const { createSchedule } = require('./schedule-manager');
+
+const POSTS_DIR = path.join(os.homedir(), '.rlhf', 'weekly-posts');
+
+function ensureDir(p) { if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true }); }
+
+/**
+ * Generate a weekly stats post file in post-everywhere format.
+ * Returns the file path.
+ */
+function generateWeeklyPostFile({ periodDays = 7 } = {}) {
+  const { post, stats } = generateWeeklyStatsPost({ periodDays });
+
+  const date = new Date().toISOString().slice(0, 10);
+  const filename = `weekly-stats-${date}.md`;
+
+  // Build post-everywhere compatible frontmatter
+  const content = [
+    '---',
+    `title: ThumbGate Weekly Stats — ${date}`,
+    'platform: x',
+    `tags: thumbgate, ai-agents, build-in-public`,
+    '---',
+    '',
+    post,
+    '',
+    '#ThumbGate #AIAgents #BuildInPublic',
+  ].join('\n');
+
+  ensureDir(POSTS_DIR);
+  const filePath = path.join(POSTS_DIR, filename);
+  fs.writeFileSync(filePath, content);
+
+  return { filePath, filename, post, stats, date };
+}
+
+/**
+ * Generate and post weekly stats. Full pipeline.
+ * If dryRun is true, generates the file but doesn't post.
+ */
+async function runWeeklyPost({ periodDays = 7, platforms, dryRun = false } = {}) {
+  const generated = generateWeeklyPostFile({ periodDays });
+
+  let postResult = null;
+  let zernioResult = null;
+
+  if (!dryRun) {
+    // Primary: Zernio API (posts to all connected platforms — X, LinkedIn, Instagram, TikTok)
+    try {
+      const { publishToAllPlatforms } = require('./social-analytics/publishers/zernio');
+      zernioResult = await publishToAllPlatforms(generated.post);
+    } catch (err) {
+      zernioResult = { error: err.message };
+    }
+
+    // Fallback: post-everywhere (if Zernio fails or specific platforms needed)
+    if (zernioResult && zernioResult.error && platforms) {
+      try {
+        const { postEverywhere } = require('./post-everywhere');
+        postResult = await postEverywhere(generated.filePath, { platforms, dryRun });
+      } catch (err) {
+        postResult = { error: err.message };
+      }
+    }
+  }
+
+  return {
+    generated,
+    posted: !dryRun,
+    zernioResult,
+    postResult,
+    dryRun,
+  };
+}
+
+/**
+ * Create a weekly schedule for auto-posting.
+ * Default: every Monday at 10:00 AM.
+ */
+function createWeeklyPostSchedule({ day = 'monday', time = '10:00', dryRun = false } = {}) {
+  const command = [
+    `const wp = require(${JSON.stringify(__filename)});`,
+    `wp.runWeeklyPost(${JSON.stringify({ dryRun })})`,
+    '.then(r => { process.stdout.write(JSON.stringify(r, null, 2) + "\\n"); })',
+    '.catch(e => { process.stderr.write(e.message + "\\n"); process.exit(1); });',
+  ].join(' ');
+
+  return createSchedule({
+    id: 'thumbgate-weekly-post',
+    name: 'ThumbGate Weekly Build-in-Public Post',
+    description: `Weekly stats post every ${day} at ${time}`,
+    schedule: `weekly ${day} ${time}`,
+    command,
+  });
+}
+
+/**
+ * List all generated weekly post files.
+ */
+function listWeeklyPosts() {
+  ensureDir(POSTS_DIR);
+  return fs.readdirSync(POSTS_DIR)
+    .filter((f) => f.endsWith('.md'))
+    .sort()
+    .reverse()
+    .map((f) => ({ filename: f, path: path.join(POSTS_DIR, f), date: f.match(/\d{4}-\d{2}-\d{2}/)?.[0] || null }));
+}
+
+module.exports = { generateWeeklyPostFile, runWeeklyPost, createWeeklyPostSchedule, listWeeklyPosts, POSTS_DIR };

package/scripts/workflow-runs.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { getFeedbackPaths } = require('./feedback-loop');
+
+const WORKFLOW_RUNS_FILE_NAME = 'workflow-runs.jsonl';
+const WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000;
+
+function getWorkflowRunsPath(feedbackDir = getFeedbackPaths().FEEDBACK_DIR) {
+  return path.join(feedbackDir, WORKFLOW_RUNS_FILE_NAME);
+}
+
+function normalizeText(value) {
+  if (value === undefined || value === null) return null;
+  const text = String(value).trim();
+  return text || null;
+}
+
+function normalizeTimestamp(value) {
+  const text = normalizeText(value);
+  if (!text) return new Date().toISOString();
+  const parsed = Date.parse(text);
+  return Number.isNaN(parsed) ? new Date().toISOString() : new Date(parsed).toISOString();
+}
+
+function normalizeProofArtifacts(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((entry) => normalizeText(entry))
+    .filter(Boolean);
+}
+
+function sanitizeWorkflowRun(entry = {}) {
+  const proofArtifacts = normalizeProofArtifacts(entry.proofArtifacts);
+  const proofBacked = Boolean(entry.proofBacked);
+  const reviewed = typeof entry.reviewed === 'boolean'
+    ? entry.reviewed
+    : Boolean(entry.reviewedBy || proofArtifacts.length > 0);
+
+  return {
+    timestamp: normalizeTimestamp(entry.timestamp),
+    workflowId: normalizeText(entry.workflowId) || 'unknown_workflow',
+    workflowName: normalizeText(entry.workflowName) || 'Unknown workflow',
+    owner: normalizeText(entry.owner) || 'unknown_owner',
+    runtime: normalizeText(entry.runtime) || 'unknown_runtime',
+    status: normalizeText(entry.status) || 'passed',
+    customerType: normalizeText(entry.customerType) || 'internal_dogfood',
+    teamId: normalizeText(entry.teamId),
+    reviewed,
+    reviewedBy: normalizeText(entry.reviewedBy),
+    proofBacked,
+    proofArtifacts,
+    source: normalizeText(entry.source),
+    metadata: entry.metadata && typeof entry.metadata === 'object' ? entry.metadata : {},
+  };
+}
+
+function resolveBusinessKey(entry = {}) {
+  const metadata = entry.metadata && typeof entry.metadata === 'object' ? entry.metadata : {};
+  return normalizeText(
+    metadata.leadId ||
+    metadata.pipelineLeadId ||
+    entry.teamId ||
+    entry.workflowId ||
+    entry.workflowName
+  );
+}
+
+function countUniqueBusinessStates(entries = [], predicate) {
+  const keys = new Set();
+  let fallbackCount = 0;
+  for (const entry of entries) {
+    if (!predicate(entry)) continue;
+    const businessKey = resolveBusinessKey(entry);
+    if (businessKey) {
+      keys.add(businessKey);
+      continue;
+    }
+    fallbackCount += 1;
+  }
+  return keys.size + fallbackCount;
+}
+
+function appendWorkflowRun(entry = {}, feedbackDir = getFeedbackPaths().FEEDBACK_DIR) {
+  const target = getWorkflowRunsPath(feedbackDir);
+  const sanitized = sanitizeWorkflowRun(entry);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.appendFileSync(target, `${JSON.stringify(sanitized)}\n`, 'utf-8');
+  return sanitized;
+}
+
+function loadWorkflowRuns(feedbackDir = getFeedbackPaths().FEEDBACK_DIR) {
+  const target = getWorkflowRunsPath(feedbackDir);
+  if (!fs.existsSync(target)) return [];
+  const raw = fs.readFileSync(target, 'utf-8').trim();
+  if (!raw) return [];
+  return raw
+    .split('\n')
+    .map((line) => {
+      try {
+        return sanitizeWorkflowRun(JSON.parse(line));
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp)));
+}
+
+function summarizeWorkflowRuns(feedbackDir = getFeedbackPaths().FEEDBACK_DIR, now = new Date()) {
+  const entries = loadWorkflowRuns(feedbackDir);
+  const windowStart = new Date(now.getTime() - WEEK_IN_MS).toISOString();
+  const proofBackedEntries = entries.filter((entry) => entry.proofBacked);
+  const recentProofBackedEntries = proofBackedEntries.filter((entry) => String(entry.timestamp) >= windowStart);
+  const weeklyWorkflowIds = new Set(recentProofBackedEntries.map((entry) => entry.workflowId).filter(Boolean));
+  const weeklyTeamKeys = new Set(
+    recentProofBackedEntries
+      .map((entry) => entry.teamId || `${entry.customerType}:${entry.workflowId}`)
+      .filter(Boolean)
+  );
+  const namedPilotAgreements = countUniqueBusinessStates(
+    entries,
+    (entry) => entry.customerType === 'named_pilot'
+  );
+  const paidTeamRuns = countUniqueBusinessStates(
+    entries,
+    (entry) => entry.customerType === 'paid_team'
+  );
+  const latestRun = entries.length ? entries[entries.length - 1] : null;
+
+  return {
+    totalRuns: entries.length,
+    proofBackedRuns: proofBackedEntries.length,
+    reviewedRuns: entries.filter((entry) => entry.reviewed).length,
+    weeklyActiveProofBackedWorkflowRuns: weeklyWorkflowIds.size,
+    weeklyTeamsRunningProofBackedWorkflows: weeklyTeamKeys.size,
+    namedPilotAgreements,
+    paidTeamRuns,
+    northStarReached: weeklyWorkflowIds.size > 0,
+    customerProofReached: namedPilotAgreements > 0 || paidTeamRuns > 0,
+    latestRun,
+  };
+}
+
+module.exports = {
+  WORKFLOW_RUNS_FILE_NAME,
+  appendWorkflowRun,
+  getWorkflowRunsPath,
+  loadWorkflowRuns,
+  sanitizeWorkflowRun,
+  summarizeWorkflowRuns,
+};