thumbgate 1.27.13 → 1.27.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thumbgate",
-  "version": "1.27.13",
+  "version": "1.27.14",
   "description": "ThumbGate self-improving agent governance: thumbs-up/down turns every mistake into a prevention rule and blocks repeat patterns. 36 pre-action checks, budget enforcement, and self-protection for Claude Code, Cursor, Codex, Gemini CLI, and Amp.",
   "homepage": "https://thumbgate.ai",
   "repository": {

package/scripts/agent-readiness.js

@@ -2,6 +2,7 @@
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const {
   getActiveMcpProfile,
@@ -165,6 +166,136 @@ function summarizePermissionTier(profileName = getActiveMcpProfile()) {
   };
 }
 
+function flattenHookCommands(value, commands = []) {
+  if (!value) return commands;
+  if (typeof value === 'string') {
+    commands.push(value);
+    return commands;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item) => flattenHookCommands(item, commands));
+    return commands;
+  }
+  if (typeof value === 'object') {
+    if (typeof value.command === 'string') commands.push(value.command);
+    Object.entries(value)
+      .filter(([key]) => key !== 'command')
+      .forEach(([, item]) => flattenHookCommands(item, commands));
+  }
+  return commands;
+}
+
+function readJsonIfExists(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function detectHookAutoCapture(projectRoot) {
+  const effectiveRoot = projectRoot || findProjectRoot();
+  const settingsFiles = ['.claude/settings.json', '.claude/settings.local.json']
+    .map((file) => path.join(effectiveRoot, file))
+    .filter((file) => fs.existsSync(file));
+  const commands = settingsFiles.flatMap((file) => {
+    const parsed = readJsonIfExists(file);
+    return flattenHookCommands(parsed && parsed.hooks && parsed.hooks.UserPromptSubmit);
+  });
+  const wiredCommands = commands.filter((command) => /hook-auto-capture(\.sh)?\b/.test(command));
+
+  return {
+    ready: wiredCommands.length > 0,
+    settingsFiles: settingsFiles.map((file) => path.relative(effectiveRoot, file)),
+    wiredCommands,
+    recommendation: wiredCommands.length > 0
+      ? 'UserPromptSubmit auto-capture hook is wired for typed thumbs feedback.'
+      : 'Run `npx thumbgate init --wire-hooks` so typed thumbs up/down feedback is captured automatically.',
+  };
+}
+
+function probeFeedbackCapture(projectRoot) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-doctor-feedback-'));
+  const previousFeedbackDir = process.env.THUMBGATE_FEEDBACK_DIR;
+  const previousProjectDir = process.env.THUMBGATE_PROJECT_DIR;
+  const previousNoNudge = process.env.THUMBGATE_NO_NUDGE;
+
+  process.env.THUMBGATE_FEEDBACK_DIR = tempDir;
+  process.env.THUMBGATE_PROJECT_DIR = projectRoot || findProjectRoot();
+  process.env.THUMBGATE_NO_NUDGE = '1';
+
+  try {
+    const {
+      captureFeedback,
+      getFeedbackPaths,
+      readJSONL,
+    } = require('./feedback-loop');
+    const result = captureFeedback({
+      signal: 'down',
+      context: 'doctor feedback loop probe: prove thumbs feedback persists to durable logs',
+      whatWentWrong: 'A runtime claimed thumbs feedback worked without verifying durable capture',
+      whatToChange: 'Run thumbgate doctor or feedback-self-test before claiming the loop is wired',
+      tags: 'doctor,feedback-loop-probe',
+    });
+    const paths = getFeedbackPaths();
+    const feedbackId = result.feedbackEvent && result.feedbackEvent.id;
+    const memoryId = result.memoryRecord && result.memoryRecord.id;
+    const feedbackStored = Boolean(feedbackId && readJSONL(paths.FEEDBACK_LOG_PATH).some((row) => row.id === feedbackId));
+    const memoryStored = Boolean(memoryId && readJSONL(paths.MEMORY_LOG_PATH).some((row) => row.id === memoryId));
+
+    return {
+      ready: Boolean(result.accepted && feedbackStored && memoryStored),
+      accepted: Boolean(result.accepted),
+      feedbackStored,
+      memoryStored,
+      feedbackId: feedbackId || null,
+      memoryId: memoryId || null,
+      mode: 'isolated-temp-store',
+      recommendation: (result.accepted && feedbackStored && memoryStored)
+        ? 'Feedback capture writes durable feedback and memory records.'
+        : 'Feedback capture did not persist both feedback and memory records; run `npx thumbgate feedback-self-test --json`.',
+    };
+  } catch (error) {
+    return {
+      ready: false,
+      accepted: false,
+      feedbackStored: false,
+      memoryStored: false,
+      feedbackId: null,
+      memoryId: null,
+      mode: 'isolated-temp-store',
+      error: error && error.message ? error.message : String(error),
+      recommendation: 'Feedback capture probe failed; run `npx thumbgate feedback-self-test --json` for details.',
+    };
+  } finally {
+    if (previousFeedbackDir === undefined) delete process.env.THUMBGATE_FEEDBACK_DIR;
+    else process.env.THUMBGATE_FEEDBACK_DIR = previousFeedbackDir;
+    if (previousProjectDir === undefined) delete process.env.THUMBGATE_PROJECT_DIR;
+    else process.env.THUMBGATE_PROJECT_DIR = previousProjectDir;
+    if (previousNoNudge === undefined) delete process.env.THUMBGATE_NO_NUDGE;
+    else process.env.THUMBGATE_NO_NUDGE = previousNoNudge;
+    try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch (_) { /* ignore cleanup failure */ }
+  }
+}
+
+function assessFeedbackLoop(projectRoot) {
+  const hookAutoCapture = detectHookAutoCapture(projectRoot);
+  const captureProbe = probeFeedbackCapture(projectRoot);
+  const ready = hookAutoCapture.ready && captureProbe.ready;
+
+  return {
+    ready,
+    automatic: hookAutoCapture.ready,
+    durableCapture: captureProbe.ready,
+    hookAutoCapture,
+    captureProbe,
+    recommendation: ready
+      ? 'Typed thumbs feedback is automatically detected and durable capture is verified.'
+      : 'Install hooks and verify capture before claiming thumbs feedback improves future runs.',
+  };
+}
+
 function generateAgentReadinessReport({
   projectRoot = PROJECT_ROOT,
   mcpProfile = null,
@@ -172,11 +303,13 @@ function generateAgentReadinessReport({
   const runtime = detectRuntimeIsolation();
   const bootstrap = collectBootstrapFiles(projectRoot);
   const permissions = summarizePermissionTier(mcpProfile || getActiveMcpProfile());
+  const feedbackLoop = assessFeedbackLoop(projectRoot);
 
   const warnings = [];
   if (!runtime.isolated) warnings.push(runtime.recommendation);
   if (!bootstrap.ready) warnings.push(bootstrap.recommendation);
   if (!permissions.ready) warnings.push(permissions.recommendation);
+  if (!feedbackLoop.ready) warnings.push(feedbackLoop.recommendation);
 
   return {
     generatedAt: new Date().toISOString(),
@@ -185,10 +318,12 @@ function generateAgentReadinessReport({
     runtime,
     bootstrap,
     permissions,
+    feedbackLoop,
     articleAlignment: {
       runtimeIsolation: runtime.isolated,
       contextConditioning: bootstrap.ready,
       permissionEnvelope: permissions.ready,
+      feedbackLoop: feedbackLoop.ready,
     },
     warnings,
   };
@@ -208,6 +343,10 @@ function reportToText(report) {
   lines.push(`Permissions: ${report.permissions.profile} (${report.permissions.tier})`);
   lines.push(`  Write-capable tools: ${report.permissions.writeCapableTools.length}`);
   lines.push(`  Recommendation: ${report.permissions.recommendation}`);
+  lines.push(`Feedback loop: ${report.feedbackLoop.ready ? 'ready' : 'needs_attention'}`);
+  lines.push(`  Auto-capture hook: ${report.feedbackLoop.automatic ? 'wired' : 'missing'}`);
+  lines.push(`  Durable capture: ${report.feedbackLoop.durableCapture ? 'verified' : 'failed'}`);
+  lines.push(`  Recommendation: ${report.feedbackLoop.recommendation}`);
 
   if (report.warnings.length > 0) {
     lines.push('');
@@ -226,6 +365,9 @@ module.exports = {
   detectRuntimeIsolation,
   collectBootstrapFiles,
   summarizePermissionTier,
+  detectHookAutoCapture,
+  probeFeedbackCapture,
+  assessFeedbackLoop,
   generateAgentReadinessReport,
   reportToText,
 };