thumbgate 1.4.2 → 1.4.4

package/scripts/ai-search-visibility.js

@@ -1,142 +0,0 @@
-'use strict';
-
-const https = require('node:https');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const PROMPTS = [
-  'best pre-action gate tools for AI coding agents',
-  'how to prevent AI coding agent from making mistakes',
-  'Claude Code safety tools',
-  'npm packages for AI agent guardrails',
-  'how to block bad tool calls in AI agents',
-  'alternatives to thumbgate',
-  'pre-tool-use hooks for AI agents',
-  'AI coding agent memory and learning',
-];
-
-function queryPerplexity(prompt, apiKey) {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify({
-      model: 'sonar',
-      messages: [{ role: 'user', content: prompt }],
-    });
-    const req = https.request(
-      {
-        hostname: 'api.perplexity.ai',
-        path: '/chat/completions',
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(body),
-        },
-      },
-      (res) => {
-        const chunks = [];
-        res.on('data', (c) => chunks.push(c));
-        res.on('end', () => {
-          try {
-            const json = JSON.parse(Buffer.concat(chunks).toString());
-            const content = json.choices?.[0]?.message?.content || '';
-            resolve(content);
-          } catch (e) {
-            reject(new Error(`Failed to parse Perplexity response: ${e.message}`));
-          }
-        });
-      }
-    );
-    req.on('error', reject);
-    req.write(body);
-    req.end();
-  });
-}
-
-async function runVisibilityCheck(opts = {}) {
-  const apiKey = opts.apiKey || process.env.PERPLEXITY_API_KEY;
-  const queryFn = opts.queryFn || (apiKey ? (p) => queryPerplexity(p, apiKey) : null);
-
-  const results = [];
-  for (const prompt of PROMPTS) {
-    if (!queryFn) {
-      results.push({ prompt, status: 'MANUAL', response: null });
-      continue;
-    }
-    try {
-      const response = await queryFn(prompt);
-      const found = /thumbgate/i.test(response);
-      results.push({ prompt, status: found ? 'FOUND' : 'MISSING', response });
-    } catch (err) {
-      results.push({ prompt, status: 'ERROR', response: null, error: err.message });
-    }
-  }
-  return results;
-}
-
-function formatReport(results) {
-  const date = new Date().toISOString().slice(0, 10);
-  const lines = [`AI Search Visibility Report — ${date}`, '='.repeat(42)];
-
-  for (const r of results) {
-    const tag = `[${r.status}]`.padEnd(10);
-    const shortPrompt =
-      r.prompt.length > 60 ? r.prompt.slice(0, 57) + '...' : r.prompt;
-    const suffix =
-      r.status === 'FOUND'
-        ? '— mentioned in response'
-        : r.status === 'MISSING'
-          ? '— not found'
-          : r.status === 'MANUAL'
-            ? '— check manually'
-            : `— ${r.error || 'error'}`;
-    lines.push(`${tag} "${shortPrompt}" ${suffix}`);
-  }
-
-  const hasApi = results.some((r) => r.status !== 'MANUAL');
-  if (hasApi) {
-    const found = results.filter((r) => r.status === 'FOUND').length;
-    const total = results.filter((r) => r.status !== 'MANUAL').length;
-    lines.push('', `Score: ${found}/${total} prompts mention ThumbGate`);
-  } else {
-    lines.push('', `Manual checklist: ${results.length} prompts to test`);
-  }
-  return lines.join('\n');
-}
-
-function saveReport(results, opts = {}) {
-  const date = new Date().toISOString().slice(0, 10);
-  const dir = opts.dir || path.join(process.cwd(), '.thumbgate', 'ai-visibility');
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-
-  const filePath = path.join(dir, `${date}.json`);
-  const found = results.filter((r) => r.status === 'FOUND').length;
-  const total = results.filter((r) => r.status !== 'MANUAL').length;
-
-  const report = {
-    date,
-    score: total > 0 ? `${found}/${total}` : 'manual',
-    results: results.map((r) => ({
-      prompt: r.prompt,
-      status: r.status,
-      ...(r.error ? { error: r.error } : {}),
-    })),
-  };
-
-  fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
-  return filePath;
-}
-
-module.exports = { PROMPTS, queryPerplexity, runVisibilityCheck, formatReport, saveReport };
-
-if (require.main === module) {
-  (async () => {
-    const results = await runVisibilityCheck();
-    const report = formatReport(results);
-    console.log(report);
-    const filePath = saveReport(results);
-    console.log(`\nReport saved to ${filePath}`);
-  })().catch((err) => {
-    console.error('Error:', err.message);
-    process.exit(1);
-  });
-}

package/scripts/autonomous-sales-agent.js

@@ -1,39 +0,0 @@
-#!/usr/bin/env node
-/**
- * autonomous-sales-agent.js
- *
- * Wrapper for the truth-aware GSD revenue loop:
- * 1. read the current commercial snapshot
- * 2. pick the correct motion (Pro vs Workflow Hardening Sprint)
- * 3. generate operator-ready outreach artifacts
- * Canonical app origin remains https://thumbgate-production.up.railway.app.
- */
-
-'use strict';
-
-const { parseArgs, runRevenueLoop } = require('./gtm-revenue-loop');
-
-async function main(argv = process.argv.slice(2)) {
-  const options = parseArgs(argv);
-  const { report, written } = await runRevenueLoop(options);
-
-  console.log('\n✅ GTM automation complete.');
-  if (written.docsPath) {
-    console.log(`Open ${written.docsPath} to review the operator report.`);
-  }
-  if (written.reportDir) {
-    console.log(`Artifacts written to ${written.reportDir}.`);
-  }
-  console.log(`State: ${report.directive.state} | Targets: ${report.targets.length}`);
-}
-
-if (require.main === module) {
-  main().catch((err) => {
-    console.error(err && err.message ? err.message : err);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  main,
-};

package/scripts/autoresearch-runner.js

@@ -1,216 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * Autoresearch Runner (AUTORESEARCH-02)
- *
- * Karpathy-inspired self-optimizing loop for the ThumbGate feedback studio.
- * Each iteration: mutate local evolution state → run primary + holdout checks
- * → measure score → keep/discard with rollback snapshots.
- *
- * The runner never rewrites tracked source files. It mutates the local
- * evolution-state overlay, evaluates in place, and only persists accepted
- * settings plus rollback snapshots.
- *
- * Mutation targets (in priority order):
- *   1. Thompson Sampling priors (HALF_LIFE_DAYS, DECAY_FLOOR)
- *   2. Prevention rule thresholds (minOccurrences)
- *   3. Verification loop retries (MAX_RETRIES)
- *   4. DPO temperature (DPO_BETA)
- *
- * Score function: command pass rate × approval weighting, with holdout gating.
- *
- * Zero external dependencies.
- *
- * Exports: runIteration, runLoop, scoreSuite, MUTATION_TARGETS
- */
-
-const {
-  getProgress,
-} = require('./experiment-tracker');
-const { buildResearchBrief } = require('./hf-papers');
-const {
-  EVOLUTION_TARGETS,
-  parseCommandScore,
-  runWorkspaceEvolution,
-} = require('./workspace-evolver');
-
-// ---------------------------------------------------------------------------
-// Mutation Targets
-// ---------------------------------------------------------------------------
-
-const MUTATION_TARGETS = EVOLUTION_TARGETS;
-
-// ---------------------------------------------------------------------------
-// Score Function
-// ---------------------------------------------------------------------------
-
-/**
- * Score a test suite run. Returns a number in [0, 1].
- *
- * @param {object} params
- * @param {string} params.testOutput - stdout from test run
- * @param {number} [params.approvalRate] - Current approval rate from feedback
- * @returns {{ score: number, testPassRate: number, details: object }}
- */
-function scoreSuite(params) {
-  return parseCommandScore(params.testOutput || '', 0, typeof params.approvalRate === 'number' ? params.approvalRate : 0.5);
-}
-
-// ---------------------------------------------------------------------------
-// Single Iteration
-// ---------------------------------------------------------------------------
-
-/**
- * Run one autoresearch iteration.
- *
- * 1. Pick a random mutation target
- * 2. Read current value, compute a random neighbor
- * 3. Run the test suite in a tmp env with the mutation
- * 4. Score and keep/discard via experiment tracker
- *
- * @param {object} [opts]
- * @param {string} [opts.targetName] - Force a specific mutation target
- * @param {number} [opts.nextValue] - Force the candidate value instead of a random neighbor
- * @param {string} [opts.testCommand] - Override test command (default: npm test)
- * @param {string[]} [opts.holdoutCommands] - Optional holdout commands required for acceptance
- * @param {number} [opts.timeoutMs] - Test timeout in ms (default: 120000)
- * @param {string} [opts.researchQuery] - Optional external research query
- * @param {number} [opts.paperLimit] - Max papers to ingest for research context
- * @param {Function} [opts.fetchImpl] - Optional fetch implementation override
- * @param {Function} [opts.searchPapersImpl] - Optional paper search override
- * @returns {Promise<object>} experiment result
- */
-async function runIteration(opts = {}) {
-  const options = opts || {};
-  const timeoutMs = options.timeoutMs || 120000;
-  const testCommand = options.testCommand || 'npm test';
-  const research = options.researchQuery
-    ? await buildResearchBrief({
-      query: options.researchQuery,
-      limit: options.paperLimit,
-      fetchImpl: options.fetchImpl,
-      searchPapersImpl: options.searchPapersImpl,
-      template: 'autoresearch-brief',
-    })
-    : null;
-
-  const result = runWorkspaceEvolution({
-    targetName: options.targetName,
-    nextValue: options.nextValue,
-    primaryCommands: [testCommand],
-    holdoutCommands: options.holdoutCommands || [],
-    timeoutMs,
-    hypothesisSuffix: research ? `Research query: ${research.query}` : null,
-    additionalMetrics: {
-      researchQuery: research ? research.query : null,
-      researchPackId: research ? research.packId : null,
-      researchPaperIds: research ? research.citations.map((citation) => citation.paperId).filter(Boolean) : [],
-    },
-  });
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Multi-Iteration Loop
-// ---------------------------------------------------------------------------
-
-/**
- * Run N autoresearch iterations.
- *
- * @param {object} params
- * @param {number} params.iterations - Number of experiments to run
- * @param {string} [params.testCommand] - Override test command
- * @param {number} [params.timeoutMs] - Per-iteration timeout
- * @param {string} [params.researchQuery] - Optional external research query
- * @param {number} [params.paperLimit] - Max papers to ingest for research context
- * @param {Function} [params.fetchImpl] - Optional fetch implementation override
- * @param {Function} [params.searchPapersImpl] - Optional paper search override
- * @returns {Promise<object>} { results, progress }
- */
-async function runLoop(params) {
-  const iterations = params.iterations || 1;
-  const results = [];
-
-  for (let i = 0; i < iterations; i++) {
-    console.log(`\n[autoresearch] Iteration ${i + 1}/${iterations}`);
-    try {
-      const result = await runIteration({
-        testCommand: params.testCommand,
-        holdoutCommands: params.holdoutCommands,
-        timeoutMs: params.timeoutMs,
-        researchQuery: params.researchQuery,
-        paperLimit: params.paperLimit,
-        fetchImpl: params.fetchImpl,
-        searchPapersImpl: params.searchPapersImpl,
-      });
-      results.push(result);
-      if (result.kept) {
-        console.log(`  ✓ KEPT: ${result.name} (delta: +${(result.delta || 0).toFixed(4)})`);
-      } else if (result.skipped) {
-        console.log(`  ⊘ SKIPPED: ${result.reason}`);
-      } else {
-        console.log(`  ✗ DISCARDED: ${result.reason}`);
-      }
-    } catch (err) {
-      console.error(`  ✗ ERROR: ${err.message}`);
-      results.push({ error: err.message });
-    }
-  }
-
-  const progress = getProgress();
-  console.log(`\n[autoresearch] Progress: ${progress.completed} experiments, ${progress.kept} kept (${progress.keepRate}%)`);
-  return { results, progress };
-}
-
-// ---------------------------------------------------------------------------
-// CLI
-// ---------------------------------------------------------------------------
-
-if (require.main === module) {
-  const args = {};
-  process.argv.slice(2).forEach((arg) => {
-    if (!arg.startsWith('--')) return;
-    const [key, ...rest] = arg.slice(2).split('=');
-    args[key] = rest.length > 0 ? rest.join('=') : true;
-  });
-
-  if (args.run) {
-    const iterations = Number(args.iterations || 1);
-    const testCommand = args['test-command'] || 'npm test';
-    const timeoutMs = Number(args.timeout || 120000);
-    const paperLimit = Number(args['paper-limit'] || 5);
-    const holdoutCommands = args.holdout ? [args.holdout] : [];
-    runLoop({
-      iterations,
-      testCommand,
-      holdoutCommands,
-      timeoutMs,
-      researchQuery: args['research-query'] || null,
-      paperLimit,
-    }).catch((error) => {
-      console.error(error.message);
-      process.exit(1);
-    });
-  } else if (args.targets) {
-    console.log('Mutation targets:');
-    MUTATION_TARGETS.forEach((t) => {
-      console.log(`  ${t.name} (${t.type}): range [${t.range.join(', ')}], step ${t.step}`);
-    });
-  } else {
-    console.log(`Usage:
-  node scripts/autoresearch-runner.js --run [--iterations=5] [--test-command="npm test"] [--holdout="npm run self-heal:check"] [--timeout=120000] [--research-query="rank fusion"] [--paper-limit=5]
-  node scripts/autoresearch-runner.js --targets`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Exports
-// ---------------------------------------------------------------------------
-
-module.exports = {
-  runIteration,
-  runLoop,
-  scoreSuite,
-  MUTATION_TARGETS,
-};

package/scripts/background-agent-governance.js

@@ -1,229 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Background Agent Governance — the missing layer for Ramp/Ona-style agent stacks.
- *
- * Background agents run unattended (writing 57% of PRs at Ramp). They need:
- * 1. Run tracking — what did each agent run do?
- * 2. Governance gate — should this PR/action be allowed based on past failures?
- * 3. Post-run audit — auto-capture feedback from CI results
- * 4. Governance report — "X runs, Y blocked, Z lessons learned"
- *
- * Integrates with: MCP server, gates engine, org dashboard, lesson inference.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { resolveFeedbackDir } = require('./feedback-paths');
-const { ensureParentDir, readJsonl } = require('./fs-utils');
-
-const RUNS_FILE = 'agent-runs.jsonl';
-
-function getFeedbackDir() { return resolveFeedbackDir(); }
-function getRunsPath() { return path.join(getFeedbackDir(), RUNS_FILE); }
-
-// ---------------------------------------------------------------------------
-// 1. Run Tracking
-// ---------------------------------------------------------------------------
-
-/**
- * Record a background agent run.
- * Called when a background agent starts or completes a task.
- */
-function recordAgentRun({ agentId, runType, source, branch, prNumber, status, gatesChecked, gatesBlocked, filesChanged, ciPassed, duration, metadata } = {}) {
-  const runsPath = getRunsPath();
-  ensureParentDir(runsPath);
-  const run = {
-    id: `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-    timestamp: new Date().toISOString(),
-    agentId: agentId || 'unknown',
-    runType: runType || 'unknown', // 'pr', 'fix', 'refactor', 'ci-repair', 'migration'
-    source: source || 'background', // 'background', 'triggered', 'scheduled', 'manual'
-    branch: branch || null,
-    prNumber: prNumber || null,
-    status: status || 'started', // 'started', 'completed', 'blocked', 'failed'
-    gatesChecked: gatesChecked || 0,
-    gatesBlocked: gatesBlocked || 0,
-    filesChanged: filesChanged || 0,
-    ciPassed: ciPassed === undefined ? null : ciPassed,
-    durationMs: duration || null,
-    metadata: metadata || {},
-  };
-  fs.appendFileSync(runsPath, JSON.stringify(run) + '\n');
-  return run;
-}
-
-// ---------------------------------------------------------------------------
-// 2. Governance Gate — pre-run check
-// ---------------------------------------------------------------------------
-
-/**
- * Check if a background agent run should proceed based on governance rules.
- * Returns { allowed, blockers, warnings, governanceScore }.
- */
-function checkRunGovernance({ agentId, runType, branch, filesChanged } = {}) {
-  const runs = readJsonl(getRunsPath());
-  const blockers = [];
-  const warnings = [];
-
-  // Rule 1: Block if this agent has > 50% failure rate in last 10 runs
-  const agentRuns = runs.filter((r) => r.agentId === agentId).slice(-10);
-  const failedRuns = agentRuns.filter((r) => r.status === 'failed' || r.status === 'blocked');
-  if (agentRuns.length >= 5 && failedRuns.length / agentRuns.length > 0.5) {
-    blockers.push({ rule: 'high_failure_rate', message: `Agent ${agentId} has ${failedRuns.length}/${agentRuns.length} failed runs (>50%)`, severity: 'critical' });
-  }
-
-  // Rule 2: Warn if agent has been blocked by gates in recent runs
-  const recentBlocked = agentRuns.filter((r) => r.gatesBlocked > 0);
-  if (recentBlocked.length >= 3) {
-    warnings.push({ rule: 'repeated_gate_blocks', message: `Agent ${agentId} has been gate-blocked in ${recentBlocked.length} recent runs`, severity: 'warning' });
-  }
-
-  // Rule 3: Block if targeting protected branch without CI passing
-  if (branch && /^(main|master|develop)$/.test(branch)) {
-    warnings.push({ rule: 'protected_branch', message: `Run targets protected branch "${branch}" — CI must pass before merge`, severity: 'warning' });
-  }
-
-  // Rule 4: Warn if too many files changed (large blast radius)
-  if (filesChanged > 20) {
-    warnings.push({ rule: 'large_blast_radius', message: `${filesChanged} files changed — consider splitting into smaller PRs`, severity: 'warning' });
-  }
-
-  const governanceScore = Math.max(0, 100 - blockers.length * 40 - warnings.length * 10);
-
-  return {
-    allowed: blockers.length === 0,
-    blockers,
-    warnings,
-    governanceScore,
-    checkedAt: new Date().toISOString(),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// 3. Post-Run Audit — auto-capture feedback from CI
-// ---------------------------------------------------------------------------
-
-/**
- * Auto-capture feedback from a completed background agent run.
- * Converts CI pass/fail into structured feedback for the learning loop.
- */
-function auditCompletedRun({ runId, agentId, ciPassed, ciOutput, prNumber, branch, filesChanged } = {}) {
-  const signal = ciPassed ? 'positive' : 'negative';
-  const context = ciPassed
-    ? `Background agent run ${runId || 'unknown'} completed successfully. PR #${prNumber || '?'} on ${branch || '?'}. ${filesChanged || 0} files changed. CI passed.`
-    : `Background agent run ${runId || 'unknown'} failed. PR #${prNumber || '?'} on ${branch || '?'}. ${filesChanged || 0} files changed. CI failed.`;
-
-  const whatWentWrong = !ciPassed && ciOutput ? ciOutput.slice(0, 500) : null;
-
-  // Record the completed run
-  const run = recordAgentRun({
-    agentId,
-    runType: 'pr',
-    source: 'background',
-    branch,
-    prNumber,
-    status: ciPassed ? 'completed' : 'failed',
-    filesChanged,
-    ciPassed,
-  });
-
-  // Auto-capture feedback
-  let feedbackResult = null;
-  try {
-    const { captureFeedback } = require('./feedback-loop');
-    feedbackResult = captureFeedback({
-      signal: ciPassed ? 'up' : 'down',
-      context,
-      whatWentWrong,
-      whatWorked: ciPassed ? `Agent successfully completed PR #${prNumber || '?'}` : undefined,
-      tags: ['background-agent', ciPassed ? 'ci-pass' : 'ci-fail', `agent:${agentId || 'unknown'}`],
-    });
-  } catch { /* feedback capture is non-critical */ }
-
-  return { run, feedbackResult, signal, context };
-}
-
-// ---------------------------------------------------------------------------
-// 4. Governance Report
-// ---------------------------------------------------------------------------
-
-/**
- * Generate a governance report for background agent runs.
- * Shows: total runs, blocked, pass rate, top failing agents, lessons learned.
- */
-function generateGovernanceReport({ periodHours = 24 } = {}) {
-  const runs = readJsonl(getRunsPath());
-  const cutoff = Date.now() - periodHours * 60 * 60 * 1000;
-  const recent = runs.filter((r) => new Date(r.timestamp).getTime() > cutoff);
-
-  const total = recent.length;
-  const completed = recent.filter((r) => r.status === 'completed').length;
-  const failed = recent.filter((r) => r.status === 'failed').length;
-  const blocked = recent.filter((r) => r.status === 'blocked').length;
-  const started = recent.filter((r) => r.status === 'started').length;
-
-  const passRate = (completed + failed) > 0 ? Math.round((completed / (completed + failed)) * 1000) / 10 : 0;
-  const totalGatesChecked = recent.reduce((s, r) => s + (r.gatesChecked || 0), 0);
-  const totalGatesBlocked = recent.reduce((s, r) => s + (r.gatesBlocked || 0), 0);
-
-  // Per-agent breakdown
-  const byAgent = {};
-  for (const r of recent) {
-    if (!byAgent[r.agentId]) byAgent[r.agentId] = { completed: 0, failed: 0, blocked: 0, total: 0 };
-    byAgent[r.agentId].total++;
-    if (r.status === 'completed') byAgent[r.agentId].completed++;
-    if (r.status === 'failed') byAgent[r.agentId].failed++;
-    if (r.status === 'blocked') byAgent[r.agentId].blocked++;
-  }
-
-  const agentSummaries = Object.entries(byAgent).map(([id, counts]) => ({
-    agentId: id,
-    ...counts,
-    passRate: (counts.completed + counts.failed) > 0 ? Math.round((counts.completed / (counts.completed + counts.failed)) * 1000) / 10 : 0,
-  })).sort((a, b) => a.passRate - b.passRate);
-
-  // By run type
-  const byType = {};
-  for (const r of recent) {
-    if (!byType[r.runType]) byType[r.runType] = 0;
-    byType[r.runType]++;
-  }
-
-  return {
-    periodHours,
-    total, completed, failed, blocked, started,
-    passRate,
-    gatesChecked: totalGatesChecked,
-    gatesBlocked: totalGatesBlocked,
-    agents: agentSummaries,
-    topFailingAgent: agentSummaries.length > 0 && agentSummaries[0].passRate < 80 ? agentSummaries[0] : null,
-    byType,
-    generatedAt: new Date().toISOString(),
-  };
-}
-
-/**
- * Format governance report as a human-readable string.
- */
-function formatGovernanceReport(report) {
-  const lines = [
-    `Background Agent Governance Report (${report.periodHours}h)`,
-    `Total runs: ${report.total} | Completed: ${report.completed} | Failed: ${report.failed} | Blocked: ${report.blocked}`,
-    `Pass rate: ${report.passRate}%`,
-    `Gates checked: ${report.gatesChecked} | Gates blocked: ${report.gatesBlocked}`,
-  ];
-  if (report.topFailingAgent) {
-    lines.push(`Top failing agent: ${report.topFailingAgent.agentId} (${report.topFailingAgent.passRate}% pass rate)`);
-  }
-  if (Object.keys(report.byType).length > 0) {
-    lines.push(`Run types: ${Object.entries(report.byType).map(([t, c]) => `${t}:${c}`).join(', ')}`);
-  }
-  return lines.join('\n');
-}
-
-module.exports = {
-  recordAgentRun, checkRunGovernance, auditCompletedRun,
-  generateGovernanceReport, formatGovernanceReport, getRunsPath,
-};