thumbgate 0.9.9

package/scripts/feedback-history-distiller.js

@@ -0,0 +1,391 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveFeedbackDir: resolveSharedFeedbackDir } = require('./feedback-paths');
+
+const DEFAULT_HISTORY_LIMIT = 10;
+
+const CORRECTION_PATTERNS = [
+  /\bdon['’]?t\b/i,
+  /\bdo not\b/i,
+  /\bnever\b/i,
+  /\bavoid\b/i,
+  /\bstop\b/i,
+  /\bmust\b/i,
+  /\bshould\b/i,
+  /\bneed to\b/i,
+  /\buse\b/i,
+  /\brun tests?\b/i,
+  /\binclude\b/i,
+  /\bprove\b/i,
+];
+
+const FAILURE_PATTERNS = [
+  /\bfailed\b/i,
+  /\bbroke\b/i,
+  /\berror\b/i,
+  /\bwrong\b/i,
+  /\bignored\b/i,
+  /\bskipped\b/i,
+  /\bhallucinat/i,
+  /\bclaimed done\b/i,
+  /\bwithout proof\b/i,
+  /\bwithout evidence\b/i,
+];
+
+const SUCCESS_PATTERNS = [
+  /\bworked\b/i,
+  /\bpassed\b/i,
+  /\bverified\b/i,
+  /\bproof\b/i,
+  /\bevidence\b/i,
+  /\btests?\b/i,
+  /\bfixed\b/i,
+  /\bsuccess/i,
+];
+
+function normalizeText(value) {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function truncate(value, max = 180) {
+  const text = normalizeText(value);
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 1).trim()}…`;
+}
+
+function appendJsonl(filePath, record) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`);
+}
+
+function readJsonlTail(filePath, limit = DEFAULT_HISTORY_LIMIT) {
+  if (!filePath || !fs.existsSync(filePath)) return [];
+  const lines = fs.readFileSync(filePath, 'utf8').split('\n');
+  const records = [];
+  for (let index = lines.length - 1; index >= 0 && records.length < limit; index -= 1) {
+    const line = lines[index].trim();
+    if (!line) continue;
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      // ignore malformed lines
+    }
+  }
+  return records.reverse();
+}
+
+function resolveFeedbackDir(feedbackDir) {
+  return resolveSharedFeedbackDir({ feedbackDir });
+}
+
+function getConversationPaths(feedbackDir) {
+  const resolved = resolveFeedbackDir(feedbackDir);
+  return {
+    feedbackDir: resolved,
+    conversationLogPath: path.join(resolved, 'conversation-window.jsonl'),
+    feedbackLogPath: path.join(resolved, 'feedback-log.jsonl'),
+  };
+}
+
+function normalizeChatHistory(entries = []) {
+  if (!Array.isArray(entries)) return [];
+  return entries
+    .map((entry) => {
+      if (typeof entry === 'string') {
+        const text = normalizeText(entry);
+        return text ? { author: null, text, timestamp: null, source: 'chat_history' } : null;
+      }
+      if (!entry || typeof entry !== 'object') return null;
+      const text = normalizeText(entry.text || entry.body || entry.message || entry.content);
+      if (!text) return null;
+      return {
+        author: normalizeText(entry.author || entry.role || entry.user || entry.name) || null,
+        text,
+        timestamp: normalizeText(entry.timestamp || entry.createdAt || entry.updatedAt) || null,
+        source: normalizeText(entry.source) || 'chat_history',
+      };
+    })
+    .filter(Boolean);
+}
+
+function recordConversationEntry(entry, options = {}) {
+  const { conversationLogPath } = getConversationPaths(options.feedbackDir);
+  const normalized = normalizeChatHistory([entry])[0];
+  if (!normalized) {
+    return { recorded: false, reason: 'empty_text', conversationLogPath };
+  }
+  const record = {
+    ...normalized,
+    timestamp: normalized.timestamp || new Date().toISOString(),
+  };
+  appendJsonl(conversationLogPath, record);
+  return { recorded: true, record, conversationLogPath };
+}
+
+function readRecentConversationWindow(options = {}) {
+  const limit = Number(options.limit || DEFAULT_HISTORY_LIMIT);
+  const { conversationLogPath } = getConversationPaths(options.feedbackDir);
+  return readJsonlTail(conversationLogPath, limit)
+    .map((entry) => normalizeChatHistory([entry])[0])
+    .filter(Boolean);
+}
+
+function findFeedbackEventById(feedbackId, options = {}) {
+  if (!feedbackId) return null;
+  const { feedbackLogPath } = getConversationPaths(options.feedbackDir);
+  const matches = readJsonlTail(feedbackLogPath, Number(options.searchLimit || 200));
+  for (let index = matches.length - 1; index >= 0; index -= 1) {
+    if (matches[index] && matches[index].id === feedbackId) {
+      return matches[index];
+    }
+  }
+  return null;
+}
+
+function buildLastActionMessage(lastAction) {
+  if (!lastAction || typeof lastAction !== 'object') return null;
+  const tool = normalizeText(lastAction.tool || lastAction.tool_name || 'unknown tool');
+  const file = normalizeText(lastAction.file || lastAction.path || '');
+  const detail = file ? `${tool} on ${file}` : tool;
+  return {
+    author: 'tool',
+    text: `Last action: ${detail}`,
+    timestamp: normalizeText(lastAction.timestamp) || null,
+    source: 'last_action',
+  };
+}
+
+function buildRelatedFeedbackMessages(feedbackEvent) {
+  if (!feedbackEvent || typeof feedbackEvent !== 'object') return [];
+  const messages = [];
+
+  if (feedbackEvent.conversationWindow && Array.isArray(feedbackEvent.conversationWindow)) {
+    for (const entry of normalizeChatHistory(feedbackEvent.conversationWindow)) {
+      messages.push({ ...entry, source: 'related_feedback_window' });
+    }
+  }
+
+  const snippets = [
+    feedbackEvent.submittedContext || null,
+    feedbackEvent.context || null,
+    feedbackEvent.whatWentWrong || null,
+    feedbackEvent.whatWorked || null,
+    feedbackEvent.whatToChange || null,
+  ].filter(Boolean);
+
+  for (const text of snippets) {
+    messages.push({
+      author: 'related-feedback',
+      text: normalizeText(text),
+      timestamp: normalizeText(feedbackEvent.timestamp) || null,
+      source: 'related_feedback',
+    });
+  }
+
+  const lastActionMessage = buildLastActionMessage(feedbackEvent.lastAction);
+  if (lastActionMessage) messages.push(lastActionMessage);
+
+  return messages;
+}
+
+function matchesAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function chooseMessage(messages, predicate) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (predicate(messages[index])) return messages[index];
+  }
+  return null;
+}
+
+function buildRuleSuggestion(correctionMessage, signal) {
+  if (!correctionMessage) return null;
+  const text = truncate(correctionMessage.text, 120);
+  if (signal === 'negative' && /\bnever\b/i.test(text)) return text;
+  if (signal === 'negative' && /\bdo not\b/i.test(text)) {
+    return text.replace(/\bdo not\b/i, 'Never');
+  }
+  if (signal === 'negative' && /\bdon['’]?t\b/i.test(text)) {
+    return text
+      .replace(/\bdon['’]?t\b/i, 'Never')
+      .replace(/\bdo not\b/i, 'Never');
+  }
+  if (signal === 'negative' && /\bavoid\b/i.test(text)) {
+    return text.replace(/\bavoid\b/i, 'Avoid');
+  }
+  if (signal === 'negative') return `Follow the earlier instruction: ${text}`;
+  return `Repeat the successful pattern: ${text}`;
+}
+
+function inferNegativeDistillation(messages, params) {
+  const correctionMessage = chooseMessage(messages, (entry) => {
+    const text = normalizeText(entry.text);
+    return Boolean(text) && matchesAny(text, CORRECTION_PATTERNS);
+  });
+
+  const failureMessage = chooseMessage(messages, (entry) => {
+    const text = normalizeText(entry.text);
+    return Boolean(text) && matchesAny(text, FAILURE_PATTERNS);
+  }) || buildLastActionMessage(params.lastAction);
+
+  if (!correctionMessage && !failureMessage) {
+    return {
+      usedHistory: false,
+      inferredFields: {},
+      lessonProposal: null,
+      evidence: [],
+      source: 'none',
+    };
+  }
+
+  const evidence = [correctionMessage, failureMessage].filter(Boolean).map((entry) => truncate(entry.text));
+  const whatWentWrong = correctionMessage
+    ? `It ignored a prior instruction: ${truncate(correctionMessage.text, 140)}`
+    : `The failure centered on: ${truncate(failureMessage.text, 140)}`;
+  const whatToChange = correctionMessage
+    ? `Follow the earlier instruction instead of repeating the same pattern: ${truncate(correctionMessage.text, 140)}`
+    : failureMessage
+      ? `Inspect and correct the failing step before repeating it: ${truncate(failureMessage.text, 140)}`
+      : null;
+  const context = failureMessage
+    ? `History-aware distillation linked this failure to ${truncate(failureMessage.text, 140)}`
+    : `History-aware distillation linked this failure to ${truncate(correctionMessage.text, 140)}`;
+
+  return {
+    usedHistory: true,
+    source: correctionMessage ? correctionMessage.source : failureMessage.source,
+    inferredFields: {
+      context,
+      whatWentWrong,
+      whatToChange,
+    },
+    lessonProposal: {
+      summary: whatWentWrong,
+      proposedRule: buildRuleSuggestion(correctionMessage, 'negative'),
+      confidence: correctionMessage && failureMessage ? 0.92 : 0.78,
+    },
+    evidence,
+  };
+}
+
+function inferPositiveDistillation(messages) {
+  const successMessage = chooseMessage(messages, (entry) => {
+    const text = normalizeText(entry.text);
+    return Boolean(text) && matchesAny(text, SUCCESS_PATTERNS);
+  });
+
+  if (!successMessage) {
+    return {
+      usedHistory: false,
+      inferredFields: {},
+      lessonProposal: null,
+      evidence: [],
+      source: 'none',
+    };
+  }
+
+  const whatWorked = `The successful pattern was: ${truncate(successMessage.text, 140)}`;
+  return {
+    usedHistory: true,
+    source: successMessage.source,
+    inferredFields: {
+      context: `History-aware distillation found a successful pattern in recent conversation: ${truncate(successMessage.text, 140)}`,
+      whatWorked,
+    },
+    lessonProposal: {
+      summary: whatWorked,
+      proposedRule: buildRuleSuggestion(successMessage, 'positive'),
+      confidence: 0.81,
+    },
+    evidence: [truncate(successMessage.text)],
+  };
+}
+
+function distillFeedbackHistory(params = {}) {
+  const signal = String(params.signal || '').toLowerCase().trim();
+  const historyLimit = Number(params.historyLimit || DEFAULT_HISTORY_LIMIT);
+  const explicitHistory = normalizeChatHistory(params.chatHistory || params.messages || []);
+  const fallbackHistory = params.allowLocalConversationFallback
+    ? readRecentConversationWindow({ feedbackDir: params.feedbackDir, limit: historyLimit })
+    : [];
+  const relatedEvent = findFeedbackEventById(params.relatedFeedbackId, {
+    feedbackDir: params.feedbackDir,
+    searchLimit: params.searchLimit,
+  });
+
+  const conversationWindow = [
+    ...explicitHistory,
+    ...(explicitHistory.length === 0 ? fallbackHistory : []),
+    ...buildRelatedFeedbackMessages(relatedEvent),
+  ]
+    .filter((entry) => entry && normalizeText(entry.text))
+    .slice(-historyLimit);
+
+  const distillation = signal === 'negative'
+    ? inferNegativeDistillation(conversationWindow, params)
+    : inferPositiveDistillation(conversationWindow, params);
+
+  return {
+    usedHistory: distillation.usedHistory,
+    source: explicitHistory.length > 0
+      ? 'chat_history'
+      : fallbackHistory.length > 0
+        ? 'local_conversation_window'
+        : relatedEvent ? 'related_feedback' : 'none',
+    conversationWindow,
+    relatedFeedbackId: relatedEvent ? relatedEvent.id : null,
+    inferredFields: distillation.inferredFields,
+    lessonProposal: distillation.lessonProposal,
+    evidence: distillation.evidence,
+  };
+}
+
+function main(argv = process.argv.slice(2)) {
+  const [command, ...rest] = argv;
+  if (command !== 'record') {
+    console.error('Usage: node scripts/feedback-history-distiller.js record --author=user --text="..."');
+    process.exit(1);
+  }
+
+  const args = {};
+  for (const token of rest) {
+    if (!token.startsWith('--')) continue;
+    const [key, ...valueParts] = token.slice(2).split('=');
+    args[key] = valueParts.join('=');
+  }
+
+  const result = recordConversationEntry({
+    author: args.author || null,
+    text: args.text || '',
+    timestamp: args.timestamp || new Date().toISOString(),
+    source: args.source || 'cli_record',
+  }, {
+    feedbackDir: args.feedbackDir,
+  });
+
+  if (!result.recorded) {
+    console.error(result.reason || 'failed_to_record');
+    process.exit(1);
+  }
+
+  process.stdout.write(JSON.stringify(result, null, 2));
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  DEFAULT_HISTORY_LIMIT,
+  distillFeedbackHistory,
+  findFeedbackEventById,
+  getConversationPaths,
+  normalizeChatHistory,
+  readRecentConversationWindow,
+  recordConversationEntry,
+};

package/scripts/feedback-inbox-read.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * Feedback Inbox Reader
+ *
+ * Reads new feedback entries from the inbox JSONL file, using a cursor
+ * to avoid reprocessing. External systems (Phoenix bridge, other agents)
+ * append feedback signals to the inbox; Amp's reflexion-preflight skill
+ * calls this script each turn to ingest new signals.
+ *
+ * Usage:
+ *   node scripts/feedback-inbox-read.js              # output new entries as JSON array
+ *   node scripts/feedback-inbox-read.js --peek        # show count without advancing cursor
+ *   node scripts/feedback-inbox-read.js --reset       # reset cursor to re-read all
+ *   node scripts/feedback-inbox-read.js --test        # run built-in tests
+ *
+ * Inbox:  .claude/feedback-loop/inbox.jsonl
+ * Cursor: .claude/feedback-loop/inbox.cursor.json
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const INBOX_PATH = path.join(PROJECT_ROOT, '.claude', 'feedback-loop', 'inbox.jsonl');
+const CURSOR_PATH = path.join(PROJECT_ROOT, '.claude', 'feedback-loop', 'inbox.cursor.json');
+
+function readInbox() {
+  if (!fs.existsSync(INBOX_PATH)) return [];
+  const raw = fs.readFileSync(INBOX_PATH, 'utf-8').trim();
+  if (!raw) return [];
+  return raw.split('\n').map((line, idx) => {
+    try {
+      return { _lineIndex: idx, ...JSON.parse(line) };
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+
+function loadCursor() {
+  if (!fs.existsSync(CURSOR_PATH)) return { lastLineIndex: -1 };
+  try {
+    return JSON.parse(fs.readFileSync(CURSOR_PATH, 'utf-8'));
+  } catch {
+    return { lastLineIndex: -1 };
+  }
+}
+
+function saveCursor(cursor) {
+  const dir = path.dirname(CURSOR_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CURSOR_PATH, JSON.stringify(cursor, null, 2) + '\n');
+}
+
+function getNewEntries(advance) {
+  const entries = readInbox();
+  if (entries.length === 0) return [];
+
+  const cursor = loadCursor();
+  const newEntries = entries.filter((e) => e._lineIndex > cursor.lastLineIndex);
+
+  if (advance && newEntries.length > 0) {
+    const maxIdx = Math.max(...newEntries.map((e) => e._lineIndex));
+    saveCursor({ lastLineIndex: maxIdx, updatedAt: new Date().toISOString() });
+  }
+
+  // Strip internal _lineIndex before returning
+  return newEntries.map(({ _lineIndex, ...rest }) => rest);
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+
+function runTests() {
+  const os = require('os');
+  let passed = 0;
+  let failed = 0;
+
+  function assert(condition, name) {
+    if (condition) { passed++; console.log(`  ✅ ${name}`); }
+    else { failed++; console.log(`  ❌ ${name}`); }
+  }
+
+  console.log('\n🧪 feedback-inbox-read.js — Tests\n');
+
+  // Setup temp inbox
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'inbox-test-'));
+  const tmpInbox = path.join(tmpDir, 'inbox.jsonl');
+  const tmpCursor = path.join(tmpDir, 'inbox.cursor.json');
+
+  // Write test entries
+  const entries = [
+    { signal: 'negative', context: 'Bad thing happened', tags: ['testing'] },
+    { signal: 'positive', context: 'Good thing happened', tags: ['testing'] },
+    { signal: 'negative', context: 'Another bad thing', tags: ['rlhf'] },
+  ];
+  fs.writeFileSync(tmpInbox, entries.map((e) => JSON.stringify(e)).join('\n') + '\n');
+
+  // Test reading all (no cursor)
+  const allEntries = (() => {
+    const raw = fs.readFileSync(tmpInbox, 'utf-8').trim();
+    return raw.split('\n').map((line, idx) => {
+      try { return { _lineIndex: idx, ...JSON.parse(line) }; }
+      catch { return null; }
+    }).filter(Boolean);
+  })();
+  assert(allEntries.length === 3, 'reads all 3 entries from inbox');
+
+  // Test cursor-based filtering
+  fs.writeFileSync(tmpCursor, JSON.stringify({ lastLineIndex: 0 }));
+  const afterFirst = allEntries.filter((e) => e._lineIndex > 0);
+  assert(afterFirst.length === 2, 'cursor at 0 → 2 new entries');
+
+  fs.writeFileSync(tmpCursor, JSON.stringify({ lastLineIndex: 2 }));
+  const afterAll = allEntries.filter((e) => e._lineIndex > 2);
+  assert(afterAll.length === 0, 'cursor at 2 → 0 new entries');
+
+  // Test loadCursor with missing file
+  const missingCursor = path.join(tmpDir, 'missing.cursor.json');
+  const fakeMod = { loadCursor: () => {
+    if (!fs.existsSync(missingCursor)) return { lastLineIndex: -1 };
+    try { return JSON.parse(fs.readFileSync(missingCursor, 'utf-8')); } catch { return { lastLineIndex: -1 }; }
+  }};
+  assert(fakeMod.loadCursor().lastLineIndex === -1, 'loadCursor returns -1 for missing file');
+
+  // Test saveCursor creates directory
+  const deepDir = path.join(tmpDir, 'deep', 'nested');
+  const deepCursor = path.join(deepDir, 'cursor.json');
+  if (!fs.existsSync(deepDir)) fs.mkdirSync(deepDir, { recursive: true });
+  fs.writeFileSync(deepCursor, JSON.stringify({ lastLineIndex: 5, updatedAt: new Date().toISOString() }) + '\n');
+  const loaded = JSON.parse(fs.readFileSync(deepCursor, 'utf-8'));
+  assert(loaded.lastLineIndex === 5, 'saveCursor persists cursor value');
+
+  // Cleanup
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  console.log(`\n${'═'.repeat(50)}`);
+  console.log(`Results: ${passed} passed, ${failed} failed, ${passed + failed} total`);
+  console.log(`${'═'.repeat(50)}\n`);
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+if (require.main === module) {
+  if (process.argv.includes('--test')) {
+    runTests();
+  } else if (process.argv.includes('--reset')) {
+    if (fs.existsSync(CURSOR_PATH)) fs.unlinkSync(CURSOR_PATH);
+    console.log('Cursor reset.');
+  } else {
+    const peek = process.argv.includes('--peek');
+    const entries = getNewEntries(!peek);
+    if (entries.length === 0) {
+      // Silent — no new entries
+      process.exit(0);
+    }
+    process.stdout.write(JSON.stringify(entries, null, 2) + '\n');
+  }
+}
+
+module.exports = { getNewEntries, readInbox, loadCursor, saveCursor, INBOX_PATH, CURSOR_PATH };