thumbgate 1.4.3 → 1.4.4

package/scripts/feedback-inbox-read.js

@@ -1,162 +0,0 @@
-#!/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: ['thumbgate'] },
-  ];
-  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 };

package/scripts/feedback-root-consolidator.js

@@ -1,233 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { ensureParentDir, readJsonl } = require('./fs-utils');
-const {
-  getThumbgateFeedbackDir,
-  listFeedbackArtifactPaths,
-} = require('./feedback-paths');
-
-const JSONL_ARTIFACTS = new Set([
-  'funnel-events.jsonl',
-  'telemetry-pings.jsonl',
-  'revenue-events.jsonl',
-  'workflow-sprint-leads.jsonl',
-]);
-
-const JSON_ARTIFACTS = new Map([
-  ['api-keys.json', () => ({ keys: {} })],
-  ['local-checkout-sessions.json', () => ({ sessions: {} })],
-]);
-
-const CONSOLIDATED_ARTIFACTS = [
-  'api-keys.json',
-  'funnel-events.jsonl',
-  'telemetry-pings.jsonl',
-  'revenue-events.jsonl',
-  'local-checkout-sessions.json',
-  'workflow-sprint-leads.jsonl',
-];
-
-function getScopedProjectOptions(options = {}) {
-  if (options.feedbackDir) return options;
-
-  const projectDir = options.projectDir || options.cwd;
-  if (!projectDir) return options;
-
-  return {
-    ...options,
-    projectDir,
-    explicitProjectDir: true,
-  };
-}
-
-function readJsonFile(filePath, fallbackFactory) {
-  if (!filePath || !fs.existsSync(filePath)) return fallbackFactory();
-  try {
-    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    return parsed && typeof parsed === 'object' ? parsed : fallbackFactory();
-  } catch {
-    return fallbackFactory();
-  }
-}
-
-function stableArtifactTimestamp(record = {}) {
-  return String(
-    record.timestamp ||
-    record.receivedAt ||
-    record.submittedAt ||
-    record.updatedAt ||
-    record.createdAt ||
-    ''
-  );
-}
-
-function dedupeJsonlRows(rows = []) {
-  const merged = [];
-  const seen = new Set();
-
-  for (const row of rows) {
-    if (!row || typeof row !== 'object') continue;
-    const key = JSON.stringify(row);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    merged.push(row);
-  }
-
-  return merged.sort((a, b) => {
-    const timeCompare = stableArtifactTimestamp(a).localeCompare(stableArtifactTimestamp(b));
-    if (timeCompare !== 0) return timeCompare;
-    return JSON.stringify(a).localeCompare(JSON.stringify(b));
-  });
-}
-
-function mergeKeyStorePayloads(payloads = []) {
-  const merged = { keys: {} };
-  for (const payload of payloads) {
-    if (!payload || typeof payload !== 'object') continue;
-    Object.assign(merged, payload);
-    merged.keys = {
-      ...(merged.keys || {}),
-      ...((payload && payload.keys) || {}),
-    };
-  }
-  return merged;
-}
-
-function mergeCheckoutSessionsPayloads(payloads = []) {
-  const merged = { sessions: {} };
-  for (const payload of payloads) {
-    if (!payload || typeof payload !== 'object') continue;
-    Object.assign(merged, payload);
-    merged.sessions = {
-      ...(merged.sessions || {}),
-      ...((payload && payload.sessions) || {}),
-    };
-  }
-  return merged;
-}
-
-function serializeJson(payload) {
-  return `${JSON.stringify(payload, null, 2)}\n`;
-}
-
-function serializeJsonl(rows = []) {
-  const serialized = rows.map((row) => JSON.stringify(row)).join('\n');
-  return serialized ? `${serialized}\n` : '';
-}
-
-function writeIfChanged(filePath, nextContent, write = true) {
-  const currentContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null;
-  const changed = currentContent !== nextContent;
-
-  if (write && changed) {
-    ensureParentDir(filePath);
-    fs.writeFileSync(filePath, nextContent, 'utf8');
-  }
-
-  return {
-    changed,
-    wrote: write && changed,
-  };
-}
-
-function consolidateJsonArtifact(fileName, primaryPath, sourcePaths, write) {
-  const fallbackFactory = JSON_ARTIFACTS.get(fileName);
-  const payloads = sourcePaths.map((candidate) => readJsonFile(candidate, fallbackFactory));
-  const merged = fileName === 'api-keys.json'
-    ? mergeKeyStorePayloads(payloads)
-    : mergeCheckoutSessionsPayloads(payloads);
-  const initializedEmpty = sourcePaths.length === 0;
-  const writeResult = writeIfChanged(primaryPath, serializeJson(merged), write);
-
-  return {
-    fileName,
-    format: 'json',
-    primaryPath,
-    sourcePaths,
-    sourceCount: sourcePaths.length,
-    initializedEmpty,
-    wrote: writeResult.wrote,
-    changed: writeResult.changed,
-    keyCount: Object.keys(merged.keys || {}).length,
-    sessionCount: Object.keys(merged.sessions || {}).length,
-  };
-}
-
-function consolidateJsonlArtifact(fileName, primaryPath, sourcePaths, write) {
-  const merged = dedupeJsonlRows(sourcePaths.flatMap((candidate) => readJsonl(candidate)));
-  const initializedEmpty = sourcePaths.length === 0;
-  const writeResult = writeIfChanged(primaryPath, serializeJsonl(merged), write);
-
-  return {
-    fileName,
-    format: 'jsonl',
-    primaryPath,
-    sourcePaths,
-    sourceCount: sourcePaths.length,
-    initializedEmpty,
-    wrote: writeResult.wrote,
-    changed: writeResult.changed,
-    rowCount: merged.length,
-  };
-}
-
-function consolidateArtifact(fileName, options = {}) {
-  const artifactPaths = listFeedbackArtifactPaths(fileName, options);
-  const primaryPath = artifactPaths[0];
-  const sourcePaths = artifactPaths.filter((candidate) => fs.existsSync(candidate));
-  const write = options.write !== false;
-
-  if (JSONL_ARTIFACTS.has(fileName)) {
-    return consolidateJsonlArtifact(fileName, primaryPath, sourcePaths, write);
-  }
-
-  return consolidateJsonArtifact(fileName, primaryPath, sourcePaths, write);
-}
-
-function consolidateFeedbackRoot(options = {}) {
-  const scopedOptions = getScopedProjectOptions(options);
-  const feedbackDir = scopedOptions.feedbackDir
-    || getThumbgateFeedbackDir(scopedOptions);
-  const artifacts = CONSOLIDATED_ARTIFACTS.map((fileName) => consolidateArtifact(fileName, {
-    ...scopedOptions,
-    feedbackDir,
-  }));
-  const sourceRoots = Array.from(new Set(
-    artifacts.flatMap((artifact) => artifact.sourcePaths.map((candidate) => path.dirname(candidate)))
-  )).sort();
-
-  return {
-    feedbackDir,
-    write: options.write !== false,
-    artifactCount: artifacts.length,
-    wroteArtifacts: artifacts.filter((artifact) => artifact.wrote).length,
-    changedArtifacts: artifacts.filter((artifact) => artifact.changed).length,
-    initializedArtifacts: artifacts.filter((artifact) => artifact.initializedEmpty).map((artifact) => artifact.fileName),
-    sourceRoots,
-    artifacts,
-  };
-}
-
-function runCli() {
-  const args = new Set(process.argv.slice(2));
-  const dryRun = args.has('--dry-run');
-  const summary = consolidateFeedbackRoot({ write: !dryRun });
-  process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
-}
-
-module.exports = {
-  CONSOLIDATED_ARTIFACTS,
-  consolidateArtifact,
-  consolidateFeedbackRoot,
-  dedupeJsonlRows,
-  getScopedProjectOptions,
-  mergeCheckoutSessionsPayloads,
-  mergeKeyStorePayloads,
-};
-
-if (require.main === module) {
-  runCli();
-}

package/scripts/feedback-to-memory.js

@@ -1,185 +0,0 @@
-#!/usr/bin/env node
-/**
- * Feedback → Memory Bridge
- *
- * Converts raw feedback params into a schema-validated memory object
- * suitable for mcp__memory__remember. This is the validation boundary
- * between external feedback signals and MCP memory storage.
- *
- * Usage:
- *   echo '{"signal":"negative","context":"...","whatWentWrong":"...","tags":["testing"]}' | node scripts/feedback-to-memory.js
- *   node scripts/feedback-to-memory.js --test
- *
- * Input (stdin JSON):
- *   signal: "positive" | "negative"
- *   context: string — what the agent was doing
- *   whatWentWrong: string — for negative: what failed
- *   whatToChange: string — for negative: how to avoid
- *   whatWorked: string — for positive: the pattern to repeat
- *   tags: string[] — optional domain tags; a fallback domain tag is inferred when omitted
- *
- * Output (stdout JSON):
- *   { ok: true, memory: { title, content, category, importance, tags } }
- *   { ok: false, reason: string, issues?: string[] }
- */
-'use strict';
-
-const { resolveFeedbackAction, prepareForStorage } = require('./feedback-schema');
-const { buildClarificationMessage } = require('./feedback-quality');
-
-function convertFeedbackToMemory(params) {
-  const action = resolveFeedbackAction({
-    signal: params.signal,
-    context: params.context || '',
-    whatWentWrong: params.whatWentWrong,
-    whatToChange: params.whatToChange,
-    whatWorked: params.whatWorked,
-    tags: params.tags || [],
-  });
-
-  if (!action || action.type === 'no-action') {
-    const clarification = buildClarificationMessage({
-      signal: params.signal,
-      context: params.context || '',
-      whatWentWrong: params.whatWentWrong,
-      whatToChange: params.whatToChange,
-      whatWorked: params.whatWorked,
-    });
-    return {
-      ok: false,
-      reason: action ? action.reason : 'Unknown action resolution failure',
-      ...(clarification || {}),
-    };
-  }
-
-  const prep = prepareForStorage(action.memory);
-  if (!prep.ok) {
-    return { ok: false, reason: `Schema validation failed: ${prep.issues.join('; ')}`, issues: prep.issues };
-  }
-
-  return { ok: true, actionType: action.type, memory: prep.memory };
-}
-
-// ---------------------------------------------------------------------------
-// CLI: stdin mode
-// ---------------------------------------------------------------------------
-
-function runStdin() {
-  let input = '';
-  process.stdin.setEncoding('utf-8');
-  process.stdin.on('data', (chunk) => { input += chunk; });
-  process.stdin.on('end', () => {
-    try {
-      const params = JSON.parse(input.trim());
-      const result = convertFeedbackToMemory(params);
-      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
-      process.exit(result.ok ? 0 : 2);
-    } catch (err) {
-      process.stdout.write(JSON.stringify({ ok: false, reason: `Parse error: ${err.message}` }, null, 2) + '\n');
-      process.exit(1);
-    }
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Built-in Tests
-// ---------------------------------------------------------------------------
-
-function runTests() {
-  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-to-memory.js — Tests\n');
-
-  // Valid negative feedback → memory
-  const neg = convertFeedbackToMemory({
-    signal: 'negative',
-    context: 'Agent claimed fix without test evidence',
-    whatWentWrong: 'No tests were run before claiming the bug was fixed',
-    whatToChange: 'Always run tests and show output before claiming done',
-    tags: ['verification', 'testing'],
-  });
-  assert(neg.ok === true, 'valid negative → ok');
-  assert(neg.actionType === 'store-mistake', 'negative → store-mistake');
-  assert(neg.memory.title.startsWith('MISTAKE:'), 'negative → MISTAKE: prefix');
-  assert(neg.memory.category === 'error', 'negative → error category');
-  assert(neg.memory.tags.includes('verification'), 'preserves domain tags');
-
-  // Valid positive feedback → memory
-  const pos = convertFeedbackToMemory({
-    signal: 'positive',
-    whatWorked: 'Built schema-validated feedback system with prevention rules',
-    tags: ['architecture', 'thumbgate'],
-  });
-  assert(pos.ok === true, 'valid positive → ok');
-  assert(pos.actionType === 'store-learning', 'positive → store-learning');
-  assert(pos.memory.title.startsWith('SUCCESS:'), 'positive → SUCCESS: prefix');
-  assert(pos.memory.category === 'learning', 'positive → learning category');
-
-  const inferredPos = convertFeedbackToMemory({
-    signal: 'positive',
-    context: 'ThumbGate automation and Claude statusline repair',
-    whatWorked: 'Verified the live ThumbGate version and fixed the stale Claude statusline wiring',
-  });
-  assert(inferredPos.ok === true, 'specific positive without tags → ok');
-  assert(inferredPos.memory.tags.includes('thumbgate'), 'infers a non-generic domain tag');
-
-  // Bare thumbs down → rejected
-  const bare = convertFeedbackToMemory({ signal: 'negative' });
-  assert(bare.ok === false, 'bare negative → rejected');
-  assert(bare.reason.includes('No context') || bare.reason.includes('cannot'), 'reports missing context');
-
-  // Bare thumbs up → rejected
-  const bareUp = convertFeedbackToMemory({ signal: 'positive' });
-  assert(bareUp.ok === false, 'bare positive → rejected');
-
-  // Unknown signal → rejected
-  const unknown = convertFeedbackToMemory({ signal: 'maybe', context: 'test' });
-  assert(unknown.ok === false, 'unknown signal → rejected');
-
-  // Context-only negative → ok
-  const ctxNeg = convertFeedbackToMemory({
-    signal: 'negative',
-    context: 'Showed fake ThumbGate statistics panel to user',
-    tags: ['thumbgate'],
-  });
-  assert(ctxNeg.ok === true, 'context-only negative → ok');
-
-  // Context-only positive → ok
-  const ctxPos = convertFeedbackToMemory({
-    signal: 'positive',
-    context: 'Ran full test suite and showed green output before responding',
-    tags: ['verification'],
-  });
-  assert(ctxPos.ok === true, 'context-only positive → ok');
-
-  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);
-}
-
-// ---------------------------------------------------------------------------
-// Exports & main
-// ---------------------------------------------------------------------------
-
-module.exports = { convertFeedbackToMemory };
-
-if (require.main === module) {
-  if (process.argv.includes('--test')) {
-    runTests();
-  } else {
-    runStdin();
-  }
-}

package/scripts/gate-satisfy.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const { satisfyCondition } = require('./gates-engine');
-
-function run() {
-  const args = process.argv.slice(2);
-  let gateId = null;
-  let evidence = '';
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--gate' && args[i + 1]) {
-      gateId = args[i + 1];
-      i++;
-    } else if (args[i] === '--evidence' && args[i + 1]) {
-      evidence = args[i + 1];
-      i++;
-    }
-  }
-
-  if (!gateId) {
-    process.stderr.write('Usage: node scripts/gate-satisfy.js --gate <gate-id> [--evidence "<text>"]\n');
-    process.exit(1);
-  }
-
-  const entry = satisfyCondition(gateId, evidence);
-  const output = { gate: gateId, satisfied: true, timestamp: entry.timestamp, evidence: entry.evidence };
-  process.stdout.write(JSON.stringify(output, null, 2) + '\n');
-}
-
-// Export for MCP tool usage
-function satisfyGate(gateId, evidence) {
-  if (!gateId) throw new Error('gate ID is required');
-  const entry = satisfyCondition(gateId, evidence || '');
-  return { gate: gateId, satisfied: true, timestamp: entry.timestamp, evidence: entry.evidence };
-}
-
-module.exports = { satisfyGate };
-
-if (require.main === module) {
-  run();
-}