thumbgate 1.4.2 → 1.4.4

package/scripts/disagreement-mining.js

@@ -1,315 +0,0 @@
-#!/usr/bin/env node
-/**
- * Disagreement Mining
- *
- * Inspired by Dropbox's "human-calibrated LLM labeling" approach.
- * The strongest learning signal comes from cases where the Thompson
- * Sampling model DISAGREES with actual user feedback signals. These
- * disagreements are prioritized for review and DPO pair generation.
- *
- * Zero external npm dependencies.
- */
-
-'use strict';
-
-const path = require('path');
-const { loadModel, getReliability } = require('./thompson-sampling');
-const { readJSONL, getFeedbackPaths, inferDomain } = require('./feedback-loop');
-const { extractDomainKeys } = require('./export-dpo-pairs');
-
-// ---------------------------------------------------------------------------
-// Domain → Thompson category mapping
-// ---------------------------------------------------------------------------
-
-/**
- * Map an inferDomain() result to the closest Thompson Sampling category.
- * Thompson uses: code_edit, git, testing, pr_review, search, architecture,
- * security, debugging, uncategorized.
- *
- * @param {string} domain - Domain from inferDomain()
- * @returns {string} Thompson category key
- */
-function domainToCategory(domain) {
-  const mapping = {
-    'testing': 'testing',
-    'security': 'security',
-    'debugging': 'debugging',
-    'architecture': 'architecture',
-    'git-workflow': 'git',
-    'ui-components': 'code_edit',
-    'api-integration': 'code_edit',
-    'documentation': 'uncategorized',
-    'data-modeling': 'architecture',
-    'performance': 'debugging',
-    'general': 'uncategorized',
-  };
-  return mapping[domain] || 'uncategorized';
-}
-
-// ---------------------------------------------------------------------------
-// Core: Mine Disagreements
-// ---------------------------------------------------------------------------
-
-/**
- * Find disagreements between Thompson model predictions and actual user signals.
- *
- * A "disagreement" is when:
- * - Thompson reliability > highThreshold (e.g. 0.6) but user gave negative signal
- * - Thompson reliability < lowThreshold (e.g. 0.4) but user gave positive signal
- *
- * @param {Object} [opts]
- * @param {string} [opts.feedbackDir] - Override feedback dir
- * @param {string} [opts.modelPath] - Override model path
- * @param {number} [opts.highThreshold=0.6] - Reliability above which positive is expected
- * @param {number} [opts.lowThreshold=0.4] - Reliability below which negative is expected
- * @returns {{ disagreements: Array, stats: Object }}
- */
-function mineDisagreements(opts) {
-  const options = opts || {};
-  const highThreshold = options.highThreshold != null ? options.highThreshold : 0.6;
-  const lowThreshold = options.lowThreshold != null ? options.lowThreshold : 0.4;
-
-  const paths = getFeedbackPaths();
-  const feedbackDir = options.feedbackDir || paths.FEEDBACK_DIR;
-  const modelPath = options.modelPath || path.join(feedbackDir, 'feedback_model.json');
-  const feedbackLogPath = path.join(feedbackDir, 'feedback-log.jsonl');
-
-  const model = loadModel(modelPath);
-  const reliability = getReliability(model);
-  const events = readJSONL(feedbackLogPath);
-
-  const disagreements = [];
-
-  for (let i = 0; i < events.length; i++) {
-    const event = events[i];
-    if (!event.signal) continue;
-
-    const isPositive = event.signal === 'positive';
-    const domain = inferDomain(event.tags, event.context);
-    const category = domainToCategory(domain);
-    const catReliability = reliability[category]
-      ? reliability[category].reliability
-      : 0.5;
-
-    let disagreementType = null;
-    let strength = 0;
-
-    if (catReliability > highThreshold && !isPositive) {
-      // Model thinks this category is reliable, but user disagrees
-      disagreementType = 'model_overconfident';
-      strength = catReliability - highThreshold;
-    } else if (catReliability < lowThreshold && isPositive) {
-      // Model thinks this category is unreliable, but user approves
-      disagreementType = 'model_underconfident';
-      strength = lowThreshold - catReliability;
-    }
-
-    if (disagreementType) {
-      disagreements.push({
-        feedbackIndex: i,
-        feedbackId: event.id || `event-${i}`,
-        signal: event.signal,
-        domain,
-        category,
-        categoryReliability: catReliability,
-        disagreementType,
-        disagreementStrength: Math.round(strength * 1000) / 1000,
-        context: event.context || '',
-        tags: event.tags || [],
-        timestamp: event.timestamp || null,
-      });
-    }
-  }
-
-  // Sort by disagreement strength descending (strongest signal first)
-  disagreements.sort((a, b) => b.disagreementStrength - a.disagreementStrength);
-
-  const rate = events.length > 0
-    ? Math.round((disagreements.length / events.length) * 1000) / 1000
-    : 0;
-
-  return {
-    disagreements,
-    stats: {
-      totalEvents: events.length,
-      disagreementCount: disagreements.length,
-      disagreementRate: rate,
-      overconfident: disagreements.filter((d) => d.disagreementType === 'model_overconfident').length,
-      underconfident: disagreements.filter((d) => d.disagreementType === 'model_underconfident').length,
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Amplify: Generate DPO pairs from disagreements
-// ---------------------------------------------------------------------------
-
-/**
- * Generate amplified DPO pairs from disagreements.
- * For each disagreement, synthesize a preference pair where:
- * - chosen = what the user signal implies (corrective direction)
- * - rejected = what the model predicted
- *
- * @param {Array} disagreements - From mineDisagreements()
- * @returns {Array} DPO preference pairs with amplification metadata
- */
-function amplifyFromDisagreements(disagreements) {
-  if (!Array.isArray(disagreements)) return [];
-
-  return disagreements.map((d) => {
-    const domainKeys = extractDomainKeys({
-      tags: d.tags,
-      title: d.context,
-    });
-    const domainLabel = domainKeys.length > 0 ? domainKeys.join(', ') : d.domain;
-
-    const prompt = `Domain: ${domainLabel}. ` +
-      `The agent performed a ${d.domain} task. ` +
-      (d.context ? `Context: ${d.context}` : 'How should the agent handle this scenario?');
-
-    let chosen;
-    let rejected;
-
-    if (d.disagreementType === 'model_overconfident') {
-      // Model thought it was good, user said no — user's correction is "chosen"
-      chosen = `The agent should NOT rely on its current ${d.domain} approach. ` +
-        `User feedback indicates failure despite model confidence of ${d.categoryReliability.toFixed(2)}. ` +
-        'Corrective action needed.';
-      rejected = `The agent's ${d.domain} approach is reliable ` +
-        `(model confidence: ${d.categoryReliability.toFixed(2)}). Continue current behavior.`;
-    } else {
-      // Model thought it was bad, user said it was fine — model is too cautious
-      chosen = `The agent's ${d.domain} approach succeeded. ` +
-        `User approved despite model skepticism (confidence: ${d.categoryReliability.toFixed(2)}). ` +
-        'This approach should be trusted more.';
-      rejected = `The agent's ${d.domain} approach is unreliable ` +
-        `(model confidence: ${d.categoryReliability.toFixed(2)}). Avoid this approach.`;
-    }
-
-    return {
-      prompt,
-      chosen,
-      rejected,
-      metadata: {
-        disagreementStrength: d.disagreementStrength,
-        disagreementType: d.disagreementType,
-        domain: d.domain,
-        category: d.category,
-        originalFeedbackId: d.feedbackId,
-        amplified: true,
-      },
-    };
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Calibrate: Cross-reference prevention rules with Thompson model
-// ---------------------------------------------------------------------------
-
-/**
- * Calibrate prevention rules by cross-referencing disagreements.
- * Only promote rules where BOTH Thompson model AND user signals agree
- * on the failure pattern (concordance check).
- *
- * @param {string} [feedbackDir] - Override feedback dir
- * @returns {{ calibratedRules: Array, droppedRules: Array, concordanceRate: number }}
- */
-function calibratePreventionRules(feedbackDir) {
-  const paths = getFeedbackPaths();
-  const dir = feedbackDir || paths.FEEDBACK_DIR;
-  const modelPath = path.join(dir, 'feedback_model.json');
-  const memoryLogPath = path.join(dir, 'memory-log.jsonl');
-
-  const model = loadModel(modelPath);
-  const reliability = getReliability(model);
-  const memories = readJSONL(memoryLogPath);
-
-  // Filter to error memories only
-  const errorMemories = memories.filter((m) => m.category === 'error');
-
-  const calibratedRules = [];
-  const droppedRules = [];
-
-  for (const mem of errorMemories) {
-    const domain = inferDomain(mem.tags, mem.content || mem.title || '');
-    const category = domainToCategory(domain);
-    const catReliability = reliability[category]
-      ? reliability[category].reliability
-      : 0.5;
-
-    const rule = {
-      domain,
-      category,
-      title: mem.title || '',
-      categoryReliability: catReliability,
-      memoryId: mem.id || null,
-    };
-
-    // Concordance: both user (error memory) and Thompson (low reliability) agree
-    if (catReliability < 0.5) {
-      calibratedRules.push(rule);
-    } else {
-      droppedRules.push(rule);
-    }
-  }
-
-  const total = calibratedRules.length + droppedRules.length;
-  const concordanceRate = total > 0
-    ? Math.round((calibratedRules.length / total) * 1000) / 1000
-    : 1;
-
-  return {
-    calibratedRules,
-    droppedRules,
-    concordanceRate,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// CLI
-// ---------------------------------------------------------------------------
-
-function parseArgs(argv) {
-  const args = {};
-  argv.forEach((arg) => {
-    if (!arg.startsWith('--')) return;
-    const [key, ...rest] = arg.slice(2).split('=');
-    args[key] = rest.length ? rest.join('=') : true;
-  });
-  return args;
-}
-
-if (require.main === module) {
-  const args = parseArgs(process.argv.slice(2));
-
-  if (args.calibrate) {
-    const result = calibratePreventionRules(args['feedback-dir']);
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    // --mine or --amplify (amplify implies mine)
-    const result = mineDisagreements({
-      feedbackDir: args['feedback-dir'],
-      modelPath: args['model-path'],
-      highThreshold: args['high-threshold'] ? Number(args['high-threshold']) : undefined,
-      lowThreshold: args['low-threshold'] ? Number(args['low-threshold']) : undefined,
-    });
-
-    if (args.amplify) {
-      const pairs = amplifyFromDisagreements(result.disagreements);
-      console.log(JSON.stringify({ pairs, stats: result.stats }, null, 2));
-    } else {
-      console.log(JSON.stringify(result, null, 2));
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Exports
-// ---------------------------------------------------------------------------
-
-module.exports = {
-  mineDisagreements,
-  amplifyFromDisagreements,
-  calibratePreventionRules,
-  domainToCategory,
-};

package/scripts/dpo-optimizer.js

@@ -1,206 +0,0 @@
-'use strict';
-/**
- * DPO Batch Optimizer (DPO-02)
- *
- * Builds (chosen, rejected) preference pairs from feedback-log.jsonl memories,
- * computes DPO log-ratio adjustments using Thompson Sampling posteriors,
- * and writes dpo-model.json to THUMBGATE_FEEDBACK_DIR.
- *
- * Does NOT call any external API. Pure offline batch optimization.
- *
- * Exports: run, buildPreferencePairs, applyDpoAdjustments, dpoLogRatio
- */
-
-const fs = require('fs');
-const path = require('path');
-const { getEffectiveSetting } = require('./evolution-state');
-const { resolveFeedbackDir } = require('./feedback-paths');
-
-const DPO_BETA = 0.1;
-
-// ---------------------------------------------------------------------------
-// dpoLogRatio — DPO preference adjustment formula
-// ---------------------------------------------------------------------------
-
-/**
- * Compute DPO adjustment in range [-1, +1] from chosen and rejected weights.
- *
- * @param {number} chosenWeight  - Time-decay weight for chosen (positive) outcome
- * @param {number} rejectedWeight - Time-decay weight for rejected (negative) outcome
- * @param {number} [beta=0.1]   - Temperature parameter (lower = more aggressive)
- * @returns {number} Adjustment in [-1, +1]
- */
-function dpoLogRatio(chosenWeight, rejectedWeight, beta) {
-  const b = (beta !== undefined && beta !== null) ? beta : getEffectiveSetting('dpo_beta', DPO_BETA);
-  const cw = Math.max(chosenWeight, 0.01);
-  const rw = Math.max(rejectedWeight, 0.01);
-  const logRatio = Math.log(cw) - Math.log(rw);
-  const sigmoid = 1.0 / (1.0 + Math.exp(-b * logRatio));
-  return (sigmoid - 0.5) * 2;
-}
-
-// ---------------------------------------------------------------------------
-// buildPreferencePairs — groups DPO pairs by category from feedbackDir
-// ---------------------------------------------------------------------------
-
-/**
- * Build preference pairs grouped by category.
- *
- * Uses buildDpoPairs() from export-dpo-pairs.js (do NOT reimplement).
- * Reads memory-log.jsonl from feedbackDir to get error + learning memories.
- *
- * @param {string} feedbackDir - Directory containing memory-log.jsonl
- * @returns {Object} Map of category → [{ chosen, rejected }]
- */
-function buildPreferencePairs(feedbackDir) {
-  const { buildDpoPairs, readJSONL } = require('./export-dpo-pairs');
-  const memoryLogPath = path.join(feedbackDir, 'memory-log.jsonl');
-  const memories = readJSONL(memoryLogPath);
-
-  const errors = memories.filter((m) => m.category === 'error');
-  const learnings = memories.filter((m) => m.category === 'learning');
-
-  const result = buildDpoPairs(errors, learnings);
-
-  // Group pairs by category (inferred from matchedKeys or tags)
-  const grouped = {};
-  for (const pair of result.pairs) {
-    const keys = (pair.metadata && pair.metadata.matchedKeys) || [];
-    const category = keys.length > 0 ? keys[0] : 'uncategorized';
-    if (!grouped[category]) grouped[category] = [];
-    grouped[category].push({
-      chosen: pair.metadata
-        ? { id: pair.metadata.learningId, content: pair.chosen, timestamp: null }
-        : { content: pair.chosen },
-      rejected: pair.metadata
-        ? { id: pair.metadata.errorId, content: pair.rejected, timestamp: null }
-        : { content: pair.rejected },
-      metadata: pair.metadata,
-    });
-  }
-
-  return grouped;
-}
-
-// ---------------------------------------------------------------------------
-// applyDpoAdjustments — mutates Thompson model with DPO posterior adjustments
-// ---------------------------------------------------------------------------
-
-/**
- * Apply DPO adjustments to Thompson Sampling posteriors and save the model.
- *
- * CRITICAL: calls ts.saveModel(model, modelPath) after all mutations.
- *
- * @param {string} modelPath - Path to feedback_model.json
- * @param {Object} pairs     - Map of category → [{ chosen, rejected }] from buildPreferencePairs
- * @returns {Object} adjustments - Map of category → { pairs, avg_adjustment }
- */
-function applyDpoAdjustments(modelPath, pairs) {
-  const ts = require('./thompson-sampling');
-  const model = ts.loadModel(modelPath);
-  const adjustments = {};
-
-  for (const [cat, catPairs] of Object.entries(pairs)) {
-    if (!catPairs || catPairs.length === 0) continue;
-
-    // Ensure category exists in model
-    if (!model.categories[cat]) {
-      model.categories[cat] = { alpha: 1.0, beta: 1.0, samples: 0, last_updated: null };
-    }
-
-    let total = 0;
-    for (const pair of catPairs) {
-      const chosenTs = (pair.chosen && pair.chosen.timestamp) || null;
-      const rejectedTs = (pair.rejected && pair.rejected.timestamp) || null;
-      const cw = ts.timeDecayWeight(chosenTs);
-      const rw = ts.timeDecayWeight(rejectedTs);
-      total += dpoLogRatio(cw, rw);
-    }
-
-    const avg = total / catPairs.length;
-
-    if (avg > 0) {
-      model.categories[cat].alpha += avg * catPairs.length * 0.5;
-    } else {
-      model.categories[cat].beta += Math.abs(avg) * catPairs.length * 0.5;
-    }
-
-    adjustments[cat] = {
-      pairs: catPairs.length,
-      avg_adjustment: Math.round(avg * 10000) / 10000,
-    };
-  }
-
-  // CRITICAL: save after all mutations (Pitfall 2 from RESEARCH.md)
-  ts.saveModel(model, modelPath);
-
-  return adjustments;
-}
-
-// ---------------------------------------------------------------------------
-// run — top-level batch DPO optimization entry point
-// ---------------------------------------------------------------------------
-
-/**
- * Run the full DPO optimization batch:
- * 1. Build preference pairs from memory-log.jsonl
- * 2. Apply DPO adjustments to Thompson model
- * 3. Write dpo-model.json to feedbackDir
- *
- * @param {Object} [opts]
- * @param {string} [opts.feedbackDir] - Override THUMBGATE_FEEDBACK_DIR
- * @param {string} [opts.modelPath]   - Override Thompson model path
- * @returns {{ adjustments: Object, pairs_processed: number }}
- */
-function run(opts) {
-  const options = opts || {};
-  const feedbackDir = options.feedbackDir || resolveFeedbackDir();
-  const modelPath = options.modelPath || path.join(feedbackDir, 'feedback_model.json');
-
-  const pairs = buildPreferencePairs(feedbackDir);
-
-  const pairsProcessed = Object.values(pairs).reduce((sum, arr) => sum + arr.length, 0);
-
-  let adjustments = {};
-  if (pairsProcessed > 0) {
-    adjustments = applyDpoAdjustments(modelPath, pairs);
-  }
-
-  const dpoModel = {
-    generated: new Date().toISOString(),
-    pairs_processed: pairsProcessed,
-    adjustments,
-  };
-
-  const dpoModelPath = path.join(feedbackDir, 'dpo-model.json');
-  if (!fs.existsSync(feedbackDir)) {
-    fs.mkdirSync(feedbackDir, { recursive: true });
-  }
-  fs.writeFileSync(dpoModelPath, `${JSON.stringify(dpoModel, null, 2)}\n`);
-
-  console.log(`DPO optimization complete: ${pairsProcessed} pairs processed`);
-  if (Object.keys(adjustments).length > 0) {
-    console.log('Adjustments:', JSON.stringify(adjustments, null, 2));
-  } else {
-    console.log('No adjustment pairs found (empty or no overlapping memories)');
-  }
-
-  return { adjustments, pairs_processed: pairsProcessed };
-}
-
-// ---------------------------------------------------------------------------
-// CLI entry point
-// ---------------------------------------------------------------------------
-
-if (require.main === module && process.argv.includes('--run')) {
-  run().catch((e) => {
-    console.error(e);
-    process.exit(1);
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Exports
-// ---------------------------------------------------------------------------
-
-module.exports = { run, buildPreferencePairs, applyDpoAdjustments, dpoLogRatio };

package/scripts/ensure-repo-bootstrap.js

@@ -1,130 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const REPO_ROOT = path.resolve(process.argv[2] || process.cwd());
-const THUMBGATE_ENTRY = {
-  command: 'npx',
-  args: ['-y', 'thumbgate@latest', 'serve'],
-};
-const MCP_SERVER_KEY = 'thumbgate';
-const LEGACY_SERVER_NAMES = ['rlhf', 'mcp-memory-gateway', 'rlhf_feedback_loop'];
-const INFO_EXCLUDE_ENTRIES = ['.thumbgate/', '.mcp.json'];
-
-function readJson(filePath) {
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function writeJsonIfChanged(filePath, value) {
-  const next = JSON.stringify(value, null, 2) + '\n';
-  let current = null;
-  try {
-    current = fs.readFileSync(filePath, 'utf8');
-  } catch {
-    current = null;
-  }
-  if (current === next) {
-    return false;
-  }
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, next);
-  return true;
-}
-
-function mergeThumbgateEntry(entry = {}) {
-  return {
-    ...entry,
-    command: THUMBGATE_ENTRY.command,
-    args: THUMBGATE_ENTRY.args.slice(),
-  };
-}
-
-function ensureMcpJson(repoRoot) {
-  const filePath = path.join(repoRoot, '.mcp.json');
-  const existing = readJson(filePath);
-  const config = existing && typeof existing === 'object' ? existing : {};
-  config.mcpServers = config.mcpServers && typeof config.mcpServers === 'object' ? config.mcpServers : {};
-  config.mcpServers[MCP_SERVER_KEY] = mergeThumbgateEntry(config.mcpServers[MCP_SERVER_KEY]);
-  for (const legacyName of LEGACY_SERVER_NAMES) {
-    delete config.mcpServers[legacyName];
-  }
-  return writeJsonIfChanged(filePath, config);
-}
-
-function ensureClaudeSettings(repoRoot) {
-  const filePath = path.join(repoRoot, '.claude', 'settings.json');
-  const existing = readJson(filePath);
-  if (!existing || typeof existing !== 'object') {
-    return false;
-  }
-  const hasRelevantServer =
-    Boolean(existing.mcpServers && existing.mcpServers[MCP_SERVER_KEY]) ||
-    LEGACY_SERVER_NAMES.some((name) => Boolean(existing.mcpServers && existing.mcpServers[name]));
-  if (!hasRelevantServer) {
-    return false;
-  }
-  existing.mcpServers = existing.mcpServers && typeof existing.mcpServers === 'object' ? existing.mcpServers : {};
-  existing.mcpServers[MCP_SERVER_KEY] = mergeThumbgateEntry(existing.mcpServers[MCP_SERVER_KEY]);
-  for (const legacyName of LEGACY_SERVER_NAMES) {
-    delete existing.mcpServers[legacyName];
-  }
-  return writeJsonIfChanged(filePath, existing);
-}
-
-function ensureInfoExclude(repoRoot) {
-  const excludePath = path.join(repoRoot, '.git', 'info', 'exclude');
-  let current = '';
-  try {
-    current = fs.readFileSync(excludePath, 'utf8');
-  } catch {
-    current = '';
-  }
-  const lines = new Set(
-    current
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter(Boolean)
-  );
-  let changed = false;
-  for (const entry of INFO_EXCLUDE_ENTRIES) {
-    if (!lines.has(entry)) {
-      lines.add(entry);
-      changed = true;
-    }
-  }
-  if (!changed) {
-    return false;
-  }
-  const next = `${Array.from(lines).sort().join('\n')}\n`;
-  fs.mkdirSync(path.dirname(excludePath), { recursive: true });
-  fs.writeFileSync(excludePath, next);
-  return true;
-}
-
-function ensureThumbgateDir(repoRoot) {
-  const thumbgateDir = path.join(repoRoot, '.thumbgate');
-  if (fs.existsSync(thumbgateDir)) {
-    return false;
-  }
-  fs.mkdirSync(thumbgateDir, { recursive: true });
-  return true;
-}
-
-function main() {
-  const results = {
-    repoRoot: REPO_ROOT,
-    createdThumbgateDir: ensureThumbgateDir(REPO_ROOT),
-    updatedMcpJson: ensureMcpJson(REPO_ROOT),
-    updatedClaudeSettings: ensureClaudeSettings(REPO_ROOT),
-    updatedInfoExclude: ensureInfoExclude(REPO_ROOT),
-  };
-  process.stdout.write(`${JSON.stringify(results)}\n`);
-}
-
-main();