thumbgate 0.9.10

package/scripts/auto-wire-hooks.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * auto-wire-hooks.js — Auto-wire PreToolUse hooks into AI agent settings.
+ *
+ * Detects the AI agent (claude-code, codex, gemini) and injects ThumbGate gate
+ * hooks into the agent's settings file. Preserves existing hooks.
+ *
+ * Usage:
+ *   node scripts/auto-wire-hooks.js --agent claude-code
+ *   node scripts/auto-wire-hooks.js                      # auto-detect
+ *   node scripts/auto-wire-hooks.js --dry-run             # preview only
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PKG_ROOT = path.join(__dirname, '..');
+
+function getHome() {
+  return process.env.HOME || process.env.USERPROFILE || '';
+}
+
+// --- Hook definitions ---
+
+function preToolHookCommand() {
+  return 'bash scripts/generate-pretool-hook.sh';
+}
+
+function userPromptHookCommand() {
+  return 'bash scripts/hook-auto-capture.sh';
+}
+
+function sessionStartHookCommand() {
+  return 'bash scripts/thumbgate_session_start.sh';
+}
+
+const CLAUDE_HOOKS = {
+  PreToolUse: {
+    matcher: 'Bash',
+    hooks: [{ type: 'command', command: preToolHookCommand() }],
+  },
+  UserPromptSubmit: {
+    hooks: [{ type: 'command', command: userPromptHookCommand() }],
+  },
+  SessionStart: {
+    hooks: [{ type: 'command', command: sessionStartHookCommand() }],
+  },
+};
+
+// --- Agent detection ---
+
+function detectAgent(flagAgent) {
+  if (flagAgent) {
+    const normalized = flagAgent.toLowerCase().replace(/[_\s]/g, '-');
+    if (['claude-code', 'claude'].includes(normalized)) return 'claude-code';
+    if (['codex'].includes(normalized)) return 'codex';
+    if (['gemini'].includes(normalized)) return 'gemini';
+    return null;
+  }
+
+  // Auto-detect by checking for config files
+  const home = getHome();
+  if (fs.existsSync(path.join(home, '.claude'))) return 'claude-code';
+  if (fs.existsSync(path.join(home, '.codex'))) return 'codex';
+  if (fs.existsSync(path.join(home, '.gemini'))) return 'gemini';
+  return null;
+}
+
+// --- Claude Code wiring ---
+
+function claudeSettingsPath() {
+  return path.join(getHome(), '.claude', 'settings.local.json');
+}
+
+function loadJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function hookAlreadyPresent(hookArray, command) {
+  if (!Array.isArray(hookArray)) return false;
+  return hookArray.some(
+    (entry) =>
+      Array.isArray(entry.hooks) &&
+      entry.hooks.some((h) => h.command === command)
+  );
+}
+
+function wireClaudeHooks(options) {
+  const settingsPath = options.settingsPath || claudeSettingsPath();
+  const dryRun = options.dryRun || false;
+
+  let settings = loadJsonFile(settingsPath) || {};
+  settings.hooks = settings.hooks || {};
+
+  const added = [];
+
+  for (const [lifecycle, hookDef] of Object.entries(CLAUDE_HOOKS)) {
+    const hookCommand = hookDef.hooks[0].command;
+
+    if (hookAlreadyPresent(settings.hooks[lifecycle], hookCommand)) {
+      continue;
+    }
+
+    settings.hooks[lifecycle] = settings.hooks[lifecycle] || [];
+    const entry = { hooks: hookDef.hooks };
+    if (hookDef.matcher) {
+      entry.matcher = hookDef.matcher;
+    }
+    settings.hooks[lifecycle].push(entry);
+    added.push({ lifecycle, command: hookCommand });
+  }
+
+  if (added.length === 0) {
+    return { changed: false, settingsPath, added: [] };
+  }
+
+  if (!dryRun) {
+    const dir = path.dirname(settingsPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+
+  return { changed: true, settingsPath, added };
+}
+
+// --- Codex wiring ---
+
+function codexConfigPath() {
+  return path.join(getHome(), '.codex', 'config.json');
+}
+
+function wireCodexHooks(options) {
+  const configPath = options.settingsPath || codexConfigPath();
+  const dryRun = options.dryRun || false;
+
+  let config = loadJsonFile(configPath) || {};
+  config.hooks = config.hooks || {};
+
+  const added = [];
+  const preToolCmd = preToolHookCommand();
+  const userPromptCmd = userPromptHookCommand();
+
+  if (!hookAlreadyPresent(config.hooks.PreToolUse, preToolCmd)) {
+    config.hooks.PreToolUse = config.hooks.PreToolUse || [];
+    config.hooks.PreToolUse.push({
+      matcher: 'Bash',
+      hooks: [{ type: 'command', command: preToolCmd }],
+    });
+    added.push({ lifecycle: 'PreToolUse', command: preToolCmd });
+  }
+
+  if (!hookAlreadyPresent(config.hooks.UserPromptSubmit, userPromptCmd)) {
+    config.hooks.UserPromptSubmit = config.hooks.UserPromptSubmit || [];
+    config.hooks.UserPromptSubmit.push({
+      hooks: [{ type: 'command', command: userPromptCmd }],
+    });
+    added.push({ lifecycle: 'UserPromptSubmit', command: userPromptCmd });
+  }
+
+  if (added.length === 0) {
+    return { changed: false, settingsPath: configPath, added: [] };
+  }
+
+  if (!dryRun) {
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  }
+
+  return { changed: true, settingsPath: configPath, added };
+}
+
+// --- Gemini wiring ---
+
+function geminiSettingsPath() {
+  return path.join(getHome(), '.gemini', 'settings.json');
+}
+
+function wireGeminiHooks(options) {
+  const settingsPath = options.settingsPath || geminiSettingsPath();
+  const dryRun = options.dryRun || false;
+
+  let settings = loadJsonFile(settingsPath) || {};
+  settings.hooks = settings.hooks || {};
+
+  const added = [];
+  const preToolCmd = preToolHookCommand();
+  const userPromptCmd = userPromptHookCommand();
+
+  if (!hookAlreadyPresent(settings.hooks.PreToolUse, preToolCmd)) {
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse || [];
+    settings.hooks.PreToolUse.push({
+      matcher: 'Bash',
+      hooks: [{ type: 'command', command: preToolCmd }],
+    });
+    added.push({ lifecycle: 'PreToolUse', command: preToolCmd });
+  }
+
+  if (!hookAlreadyPresent(settings.hooks.UserPromptSubmit, userPromptCmd)) {
+    settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit || [];
+    settings.hooks.UserPromptSubmit.push({
+      hooks: [{ type: 'command', command: userPromptCmd }],
+    });
+    added.push({ lifecycle: 'UserPromptSubmit', command: userPromptCmd });
+  }
+
+  if (added.length === 0) {
+    return { changed: false, settingsPath, added: [] };
+  }
+
+  if (!dryRun) {
+    const dir = path.dirname(settingsPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  }
+
+  return { changed: true, settingsPath, added };
+}
+
+// --- Dispatcher ---
+
+function wireHooks(options) {
+  const agent = detectAgent(options.agent);
+  if (!agent) {
+    return {
+      error: 'Could not detect AI agent. Use --agent=claude-code|codex|gemini',
+      agent: null,
+      changed: false,
+    };
+  }
+
+  let result;
+  switch (agent) {
+    case 'claude-code':
+      result = wireClaudeHooks(options);
+      break;
+    case 'codex':
+      result = wireCodexHooks(options);
+      break;
+    case 'gemini':
+      result = wireGeminiHooks(options);
+      break;
+    default:
+      return { error: `Unsupported agent: ${agent}`, agent, changed: false };
+  }
+
+  return { ...result, agent };
+}
+
+function parseFlags(argv) {
+  const flags = {};
+  for (const arg of argv) {
+    if (arg === '--dry-run') flags.dryRun = true;
+    if (arg === '--wire-hooks') flags.wireHooks = true;
+    if (arg.startsWith('--agent=')) flags.agent = arg.slice('--agent='.length);
+    if (arg.startsWith('--agent') && !arg.includes('=')) {
+      const idx = argv.indexOf(arg);
+      if (idx + 1 < argv.length && !argv[idx + 1].startsWith('--')) {
+        flags.agent = argv[idx + 1];
+      }
+    }
+  }
+  return flags;
+}
+
+// --- Exports ---
+
+module.exports = {
+  detectAgent,
+  wireHooks,
+  wireClaudeHooks,
+  wireCodexHooks,
+  wireGeminiHooks,
+  hookAlreadyPresent,
+  loadJsonFile,
+  parseFlags,
+  claudeSettingsPath,
+  codexConfigPath,
+  geminiSettingsPath,
+  CLAUDE_HOOKS,
+  preToolHookCommand,
+  userPromptHookCommand,
+  sessionStartHookCommand,
+};
+
+if (require.main === module) {
+  const flags = parseFlags(process.argv.slice(2));
+  const result = wireHooks(flags);
+
+  if (result.error) {
+    console.error(result.error);
+    process.exit(1);
+  }
+
+  if (!result.changed) {
+    console.log(`Hooks already wired for ${result.agent} at ${result.settingsPath}`);
+  } else {
+    const prefix = flags.dryRun ? '[DRY RUN] Would add' : 'Added';
+    console.log(`${prefix} hooks for ${result.agent}:`);
+    for (const h of result.added) {
+      console.log(`  ${h.lifecycle}: ${h.command}`);
+    }
+    console.log(`  Settings: ${result.settingsPath}`);
+  }
+}

package/scripts/autonomous-sales-agent.js

@@ -0,0 +1,39 @@
+#!/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

@@ -0,0 +1,216 @@
+#!/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,
+};