thumbgate 0.9.10 → 0.9.12

package/scripts/ensure-repo-bootstrap.js

@@ -0,0 +1,129 @@
+#!/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 RLHF_ENTRY = {
+  command: 'npx',
+  args: ['-y', 'thumbgate@latest', 'serve'],
+};
+const LEGACY_SERVER_NAMES = ['thumbgate', 'rlhf_feedback_loop'];
+const INFO_EXCLUDE_ENTRIES = ['.rlhf/', '.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 mergeRlhfEntry(entry = {}) {
+  return {
+    ...entry,
+    command: RLHF_ENTRY.command,
+    args: RLHF_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.rlhf = mergeRlhfEntry(config.mcpServers.rlhf);
+  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.rlhf) ||
+    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.rlhf = mergeRlhfEntry(existing.mcpServers.rlhf);
+  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 ensureRlhfDir(repoRoot) {
+  const rlhfDir = path.join(repoRoot, '.rlhf');
+  if (fs.existsSync(rlhfDir)) {
+    return false;
+  }
+  fs.mkdirSync(rlhfDir, { recursive: true });
+  return true;
+}
+
+function main() {
+  const results = {
+    repoRoot: REPO_ROOT,
+    createdRlhfDir: ensureRlhfDir(REPO_ROOT),
+    updatedMcpJson: ensureMcpJson(REPO_ROOT),
+    updatedClaudeSettings: ensureClaudeSettings(REPO_ROOT),
+    updatedInfoExclude: ensureInfoExclude(REPO_ROOT),
+  };
+  process.stdout.write(`${JSON.stringify(results)}\n`);
+}
+
+main();

package/scripts/export-dpo-pairs.js

@@ -8,10 +8,9 @@
 const fs = require('fs');
 const path = require('path');
 const { traceForDpoPair, aggregateTraces } = require('./code-reasoning');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
-const PROJECT_ROOT = path.join(__dirname, '..');
-const FEEDBACK_DIR = process.env.THUMBGATE_FEEDBACK_DIR || path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
-const DEFAULT_LOCAL_MEMORY_LOG = path.join(FEEDBACK_DIR, 'memory-log.jsonl');
+const DEFAULT_LOCAL_MEMORY_LOG = path.join(resolveFeedbackDir(), 'memory-log.jsonl');
 
 function readJSONL(filePath) {
   if (!fs.existsSync(filePath)) return [];

package/scripts/export-kto-pairs.js

@@ -12,11 +12,10 @@
 
 const fs = require('fs');
 const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
-const PROJECT_ROOT = path.join(__dirname, '..');
-const FEEDBACK_DIR = process.env.THUMBGATE_FEEDBACK_DIR || path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
-const DEFAULT_FEEDBACK_LOG = path.join(FEEDBACK_DIR, 'feedback-log.jsonl');
-const DEFAULT_MEMORY_LOG = path.join(FEEDBACK_DIR, 'memory-log.jsonl');
+const DEFAULT_FEEDBACK_LOG = path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
+const DEFAULT_MEMORY_LOG = path.join(resolveFeedbackDir(), 'memory-log.jsonl');
 
 function readJSONL(filePath) {
   if (!fs.existsSync(filePath)) return [];

package/scripts/export-training.js

@@ -16,12 +16,14 @@
 
 const fs = require('fs');
 const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
-const PROJECT_ROOT = path.join(__dirname, '..');
-const FEEDBACK_DIR = process.env.THUMBGATE_FEEDBACK_DIR
-  || path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
 const SEQUENCE_WINDOW = 10;
 
+function getFeedbackDir() {
+  return resolveFeedbackDir();
+}
+
 // ---------------------------------------------------------------------------
 // Utility helpers
 // ---------------------------------------------------------------------------
@@ -173,7 +175,7 @@ function buildPreferencePairs(feedbackEntries) {
  * @returns {{ outputPath: string, pairCount: number, sequenceCount: number }}
  */
 function exportPyTorchJSON(feedbackDir, outputPath) {
-  const fbDir = feedbackDir || FEEDBACK_DIR;
+  const fbDir = feedbackDir || getFeedbackDir();
   const feedbackPath = path.join(fbDir, 'feedback-log.jsonl');
   const sequencePath = path.join(fbDir, 'feedback-sequences.jsonl');
   const exportDir = path.join(fbDir, 'training-data');
@@ -246,7 +248,7 @@ function escapeCsvField(value) {
  * @returns {{ outputPath: string, rowCount: number }}
  */
 function exportCSV(feedbackDir, outputPath) {
-  const fbDir = feedbackDir || FEEDBACK_DIR;
+  const fbDir = feedbackDir || getFeedbackDir();
   const feedbackPath = path.join(fbDir, 'feedback-log.jsonl');
   const exportDir = path.join(fbDir, 'training-data');
 
@@ -288,7 +290,7 @@ function exportCSV(feedbackDir, outputPath) {
  * @returns {{ outputPath: string, report: object }}
  */
 function exportActionAnalysis(feedbackDir, outputPath) {
-  const fbDir = feedbackDir || FEEDBACK_DIR;
+  const fbDir = feedbackDir || getFeedbackDir();
   const feedbackPath = path.join(fbDir, 'feedback-log.jsonl');
   const sequencePath = path.join(fbDir, 'feedback-sequences.jsonl');
   const exportDir = path.join(fbDir, 'training-data');

package/scripts/feedback-attribution.js

@@ -3,14 +3,24 @@
 
 const fs = require('fs');
 const path = require('path');
+const { resolveFeedbackDir } = require('./feedback-paths');
+
+function getAttributionPaths(options = {}) {
+  const feedbackDir = resolveFeedbackDir({
+    cwd: options.cwd,
+    env: options.env,
+    feedbackDir: options.feedbackDir,
+    home: options.home,
+  });
+  return {
+    feedbackDir,
+    actionLog: path.join(feedbackDir, 'action-log.jsonl'),
+    attributions: path.join(feedbackDir, 'feedback-attributions.jsonl'),
+    attributedFeedback: path.join(feedbackDir, 'attributed-feedback.jsonl'),
+  };
+}
 
-// ThumbGate repo: scripts/ is 1 level below repo root (not 2 like Subway .claude/scripts/feedback/)
-const ROOT = path.join(__dirname, '..');
-const PATHS = {
-  actionLog: path.join(ROOT, '.claude', 'memory', 'feedback', 'action-log.jsonl'),
-  attributions: path.join(ROOT, '.claude', 'memory', 'feedback', 'feedback-attributions.jsonl'),
-  attributedFeedback: path.join(ROOT, '.claude', 'memory', 'feedback', 'attributed-feedback.jsonl'),
-};
+const PATHS = getAttributionPaths();
 
 const STOPWORDS = new Set([
   'about', 'after', 'again', 'allow', 'already', 'always', 'because', 'before', 'being', 'between',
@@ -155,7 +165,7 @@ function scoreCandidate(action, feedbackNormalized, feedbackTokens, nowMs) {
 }
 
 function recordAction(toolName, toolInput, opts = {}) {
-  const actionLogPath = opts.actionLogPath || process.env.THUMBGATE_ACTION_LOG || PATHS.actionLog;
+  const actionLogPath = opts.actionLogPath || process.env.THUMBGATE_ACTION_LOG || getAttributionPaths(opts).actionLog;
   const tool = String(toolName || 'unknown');
   const inputSummary = summarizeToolInput(tool, toolInput);
   const normalized = normalize(inputSummary);
@@ -175,9 +185,10 @@ function recordAction(toolName, toolInput, opts = {}) {
 
 function attributeFeedback(signal, feedbackContext, opts = {}) {
   const sig = String(signal || '').toLowerCase().trim();
-  const actionLogPath = opts.actionLogPath || process.env.THUMBGATE_ACTION_LOG || PATHS.actionLog;
-  const attributionsPath = opts.attributionsPath || process.env.THUMBGATE_FEEDBACK_ATTRIBUTIONS || PATHS.attributions;
-  const attributedFeedbackPath = opts.attributedFeedbackPath || process.env.THUMBGATE_ATTRIBUTED_FEEDBACK || PATHS.attributedFeedback;
+  const paths = getAttributionPaths(opts);
+  const actionLogPath = opts.actionLogPath || process.env.THUMBGATE_ACTION_LOG || paths.actionLog;
+  const attributionsPath = opts.attributionsPath || process.env.THUMBGATE_FEEDBACK_ATTRIBUTIONS || paths.attributions;
+  const attributedFeedbackPath = opts.attributedFeedbackPath || process.env.THUMBGATE_ATTRIBUTED_FEEDBACK || paths.attributedFeedback;
 
   if (sig !== 'negative' && sig !== 'positive') {
     return { ok: true, skipped: true, reason: 'signal_not_supported' };
@@ -298,6 +309,7 @@ if (require.main === module) {
 
 module.exports = {
   PATHS,
+  getAttributionPaths,
   readJsonl,
   appendJsonl,
   normalize,

package/scripts/feedback-loop.js

@@ -105,8 +105,7 @@ const pendingBackgroundSideEffects = new Set();
  */
 function updateStatuslineWithLesson({ accepted, signal, memoryId, feedbackId, lesson, turnCount }) {
   try {
-    const cacheDir = process.env.THUMBGATE_FEEDBACK_DIR || HOME || '.';
-    const cachePath = path.join(cacheDir, '.thumbgate', 'statusline_cache.json');
+    const cachePath = path.join(getFeedbackPaths().FEEDBACK_DIR, 'statusline_cache.json');
     let cache = {};
     try {
       cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
@@ -138,6 +137,12 @@ function updateStatuslineWithLesson({ accepted, signal, memoryId, feedbackId, le
     cache.updated_at = String(Math.floor(Date.now() / 1000));
     fs.mkdirSync(path.dirname(cachePath), { recursive: true });
     fs.writeFileSync(cachePath, JSON.stringify(cache));
+    try {
+      const { refreshStatuslineCache } = require('./hook-thumbgate-cache-updater');
+      refreshStatuslineCache(analyzeFeedback(), cachePath);
+    } catch {
+      /* keep lesson refresh best-effort */
+    }
   } catch { /* statusline update is best-effort */ }
 }
 
@@ -615,6 +620,35 @@ function enrichFeedbackContext(feedbackEvent, params) {
         ? params.filePaths.split(',').map((f) => f.trim()).filter(Boolean)
         : [];
     const errorType = params.errorType || null;
+    const protectedFiles = filePaths.filter((filePath) => /(^|\/)(agents\.md|claude(\.local)?\.md|gemini\.md|readme\.md|\.gitignore|skill\.md)$|^\.husky\/|^config\/gates\//i.test(filePath));
+    const combinedText = [
+      feedbackEvent.context || '',
+      feedbackEvent.whatWentWrong || '',
+      feedbackEvent.whatToChange || '',
+      ...(Array.isArray(feedbackEvent.tags) ? feedbackEvent.tags : []),
+    ].join(' ').toLowerCase();
+    const includesPhrase = (phrase) => combinedText.includes(phrase);
+    const includesOrderedTerms = (firstTerm, secondTerm) => {
+      const firstIndex = combinedText.indexOf(firstTerm);
+      if (firstIndex === -1) return false;
+      return combinedText.indexOf(secondTerm, firstIndex + firstTerm.length) !== -1;
+    };
+    const enforcement = {
+      scopeViolation: includesPhrase('scope creep')
+        || includesPhrase('out of scope')
+        || includesOrderedTerms('outside', 'scope')
+        || includesPhrase('wrong files')
+        || includesPhrase('unrelated files'),
+      approvalFailure: includesPhrase('without approval')
+        || includesPhrase('missing approval')
+        || includesPhrase('approval required')
+        || includesPhrase('permission required'),
+      protectedFileViolation: protectedFiles.length > 0
+        || includesPhrase('protected file')
+        || includesPhrase('policy file')
+        || includesPhrase('hook file'),
+      protectedFiles,
+    };
 
     return {
       ...feedbackEvent,
@@ -623,6 +657,7 @@ function enrichFeedbackContext(feedbackEvent, params) {
         filePaths,
         errorType,
         outcomeCategory,
+        enforcement,
       },
     };
   } catch (_err) {
@@ -812,6 +847,9 @@ function inferLessonFromConversation(conversationWindow, signal) {
   const tags = [];
   if (filePaths.length > 0) tags.push('has-file-context');
   if (errorPatterns.length > 0) tags.push('has-error-context');
+  if (filePaths.some((filePath) => /(^|\/)(agents\.md|claude(\.local)?\.md|gemini\.md|readme\.md|\.gitignore|skill\.md)$|^\.husky\/|^config\/gates\//i.test(filePath))) {
+    tags.push('protected-file-context');
+  }
 
   return {
     lesson,

package/scripts/feedback-to-rules.js

@@ -3,8 +3,9 @@
 const fs = require('fs');
 const path = require('path');
 const { getAutoGatesPath } = require('./auto-promote-gates');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
-const DEFAULT_LOG = path.join(__dirname, '..', '.claude', 'memory', 'feedback', 'feedback-log.jsonl');
+const DEFAULT_LOG = path.join(resolveFeedbackDir(), 'feedback-log.jsonl');
 const NEG = new Set(['negative', 'negative_strong', 'down', 'thumbs_down']);
 const POS = new Set(['positive', 'positive_strong', 'up', 'thumbs_up']);
 

package/scripts/filesystem-search.js

@@ -19,9 +19,10 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_FEEDBACK_DIR = path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+const DEFAULT_FEEDBACK_DIR = resolveFeedbackDir();
 const DEFAULT_CONTEXTFS_DIR = path.join(DEFAULT_FEEDBACK_DIR, 'contextfs');
 
 // ---------------------------------------------------------------------------
@@ -29,7 +30,7 @@ const DEFAULT_CONTEXTFS_DIR = path.join(DEFAULT_FEEDBACK_DIR, 'contextfs');
 // ---------------------------------------------------------------------------
 
 function getFeedbackDir() {
-  return process.env.THUMBGATE_FEEDBACK_DIR || DEFAULT_FEEDBACK_DIR;
+  return resolveFeedbackDir();
 }
 
 function getContextFsDir() {