thumbgate 0.9.9

package/scripts/feedback-paths.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir() || '';
+
+function buildFeedbackPathsFromDir(dirPath) {
+  return {
+    FEEDBACK_DIR: dirPath,
+    FEEDBACK_LOG_PATH: path.join(dirPath, 'feedback-log.jsonl'),
+    DIAGNOSTIC_LOG_PATH: path.join(dirPath, 'diagnostic-log.jsonl'),
+    MEMORY_LOG_PATH: path.join(dirPath, 'memory-log.jsonl'),
+    REJECTION_LEDGER_PATH: path.join(dirPath, 'rejection-ledger.jsonl'),
+    SUMMARY_PATH: path.join(dirPath, 'feedback-summary.json'),
+    PREVENTION_RULES_PATH: path.join(dirPath, 'prevention-rules.md'),
+  };
+}
+
+function uniquePaths(paths = []) {
+  const seen = new Set();
+  const unique = [];
+
+  for (const candidate of paths) {
+    if (!candidate) continue;
+    const resolved = path.resolve(candidate);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    unique.push(candidate);
+  }
+
+  return unique;
+}
+
+function dirExists(dirPath) {
+  try {
+    return Boolean(dirPath && fs.existsSync(dirPath));
+  } catch {
+    return false;
+  }
+}
+
+function getProjectName(cwd = process.cwd()) {
+  return path.basename(cwd || PROJECT_ROOT) || 'default';
+}
+
+function getExplicitFeedbackDir(options = {}) {
+  const env = options.env || process.env;
+  if (options.feedbackDir) return options.feedbackDir;
+  if (env.THUMBGATE_FEEDBACK_DIR) return env.THUMBGATE_FEEDBACK_DIR;
+  if (env.RAILWAY_VOLUME_MOUNT_PATH) {
+    return path.join(env.RAILWAY_VOLUME_MOUNT_PATH, 'feedback');
+  }
+  return null;
+}
+
+function getThumbgateFeedbackDir(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  return path.join(cwd, '.thumbgate');
+}
+
+function getRlhfFeedbackDir(options = {}) {
+  const env = options.env || process.env;
+  if (env._TEST_RLHF_FEEDBACK_DIR) return env._TEST_RLHF_FEEDBACK_DIR;
+  if (env.THUMBGATE_RLHF_FEEDBACK_DIR) return env.THUMBGATE_RLHF_FEEDBACK_DIR;
+  const cwd = options.cwd || process.cwd();
+  return path.join(cwd, '.rlhf');
+}
+
+function getLegacyFeedbackDir(options = {}) {
+  const env = options.env || process.env;
+  if (env._TEST_LEGACY_FEEDBACK_DIR) return env._TEST_LEGACY_FEEDBACK_DIR;
+  if (env.THUMBGATE_LEGACY_FEEDBACK_DIR) return env.THUMBGATE_LEGACY_FEEDBACK_DIR;
+  const cwd = options.cwd || process.cwd();
+  return path.join(cwd, '.claude', 'memory', 'feedback');
+}
+
+function getGlobalFeedbackDir(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const home = options.home || HOME;
+  return path.join(home, '.thumbgate', 'projects', getProjectName(cwd));
+}
+
+function resolveFeedbackDir(options = {}) {
+  const explicit = getExplicitFeedbackDir(options);
+  if (explicit) return explicit;
+
+  const localThumbgate = getThumbgateFeedbackDir(options);
+  if (dirExists(localThumbgate)) return localThumbgate;
+
+  const localRlhf = getRlhfFeedbackDir(options);
+  if (dirExists(localRlhf)) return localRlhf;
+
+  const localLegacy = getLegacyFeedbackDir(options);
+  if (dirExists(localLegacy)) return localLegacy;
+
+  return getGlobalFeedbackDir(options);
+}
+
+function getFeedbackPaths(options = {}) {
+  return buildFeedbackPathsFromDir(resolveFeedbackDir(options));
+}
+
+function listFallbackFeedbackDirs(options = {}) {
+  const activeDir = path.resolve(resolveFeedbackDir(options));
+  return uniquePaths([
+    getRlhfFeedbackDir(options),
+    getLegacyFeedbackDir(options),
+  ]).filter((dirPath) => path.resolve(dirPath) !== activeDir);
+}
+
+function listFeedbackArtifactPaths(fileName, options = {}) {
+  if (!fileName) return [];
+  const activeDir = resolveFeedbackDir(options);
+  return uniquePaths([
+    path.join(activeDir, fileName),
+    ...listFallbackFeedbackDirs(options).map((dirPath) => path.join(dirPath, fileName)),
+  ]);
+}
+
+function resolveFallbackArtifactPath(fileName, options = {}) {
+  const fallbackPaths = listFallbackFeedbackDirs(options).map((dirPath) => path.join(dirPath, fileName));
+  for (const candidate of fallbackPaths) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return fallbackPaths[0] || null;
+}
+
+module.exports = {
+  PROJECT_ROOT,
+  HOME,
+  buildFeedbackPathsFromDir,
+  getFeedbackPaths,
+  getGlobalFeedbackDir,
+  getLegacyFeedbackDir,
+  getRlhfFeedbackDir,
+  getThumbgateFeedbackDir,
+  listFallbackFeedbackDirs,
+  listFeedbackArtifactPaths,
+  resolveFallbackArtifactPath,
+  resolveFeedbackDir,
+};

package/scripts/feedback-quality.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const GENERIC_PHRASE_RULES = {
+  positive: [
+    /^up$/,
+    /^thumbs?\s*up$/,
+    /^thumbs\s+up$/,
+    /^that worked$/,
+    /^it worked$/,
+    /^worked$/,
+    /^looks good$/,
+    /^looked good$/,
+    /^good job$/,
+    /^good work$/,
+    /^nice work$/,
+    /^perfect$/,
+    /^approved$/,
+    /^lgtm$/,
+  ],
+  negative: [
+    /^down$/,
+    /^thumbs?\s*down$/,
+    /^thumbs\s+down$/,
+    /^that failed$/,
+    /^it failed$/,
+    /^failed$/,
+    /^that was wrong$/,
+    /^wrong$/,
+    /^bad$/,
+    /^fix this$/,
+    /^broken$/,
+  ],
+};
+
+const CLARIFICATION_CONFIG = {
+  positive: {
+    prompt: 'What specifically worked that should be repeated?',
+    example: 'Example: "The agent showed test output before claiming done."',
+    missingFields: ['whatWorked'],
+  },
+  negative: {
+    prompt: 'What failed and what should change next time?',
+    example: 'Example: "It skipped tests and should run npm test before closing the task."',
+    missingFields: ['whatWentWrong', 'whatToChange'],
+  },
+};
+
+function normalizeFeedbackSignal(signal) {
+  const normalized = normalizeFeedbackText(signal);
+  if (['negative', 'down', 'thumbs down', 'thumbsdown', 'bad'].includes(normalized)) {
+    return 'negative';
+  }
+  return 'positive';
+}
+
+function normalizeFeedbackText(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[_-]+/g, ' ')
+    .replace(/[^\w\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isGenericFeedbackText(value, signal) {
+  const normalized = normalizeFeedbackText(value);
+  if (!normalized) return false;
+  const rules = GENERIC_PHRASE_RULES[signal] || [];
+  return rules.some((pattern) => pattern.test(normalized));
+}
+
+function assessFeedbackActionability(params = {}) {
+  const signal = normalizeFeedbackSignal(params.signal);
+  const primaryFields = signal === 'positive'
+    ? [
+      { name: 'whatWorked', value: params.whatWorked },
+      { name: 'context', value: params.context },
+    ]
+    : [
+      { name: 'whatWentWrong', value: params.whatWentWrong },
+      { name: 'context', value: params.context },
+    ];
+
+  const populated = primaryFields.filter((field) => normalizeFeedbackText(field.value));
+  const specific = populated.find((field) => !isGenericFeedbackText(field.value, signal));
+
+  if (specific) {
+    return {
+      promotable: true,
+      signal,
+      sourceField: specific.name,
+      prompt: null,
+      example: null,
+      missingFields: [],
+      issue: null,
+      isGenericContext: false,
+    };
+  }
+
+  const config = CLARIFICATION_CONFIG[signal];
+  const issue = populated.length > 0 ? 'generic' : 'missing';
+
+  return {
+    promotable: false,
+    signal,
+    sourceField: null,
+    prompt: config.prompt,
+    example: config.example,
+    missingFields: config.missingFields,
+    issue,
+    isGenericContext: populated.some((field) => field.name === 'context'),
+  };
+}
+
+function buildClarificationMessage(params = {}) {
+  const assessment = assessFeedbackActionability(params);
+  if (assessment.promotable) return null;
+
+  const intro = assessment.signal === 'positive'
+    ? 'Positive signal logged, but it is not specific enough to promote to reusable memory.'
+    : 'Negative signal logged, but it is not specific enough to promote to reusable memory.';
+
+  return {
+    needsClarification: true,
+    prompt: assessment.prompt,
+    example: assessment.example,
+    missingFields: assessment.missingFields,
+    message: `${intro} ${assessment.prompt}`,
+  };
+}
+
+module.exports = {
+  GENERIC_PHRASE_RULES,
+  normalizeFeedbackSignal,
+  normalizeFeedbackText,
+  isGenericFeedbackText,
+  assessFeedbackActionability,
+  buildClarificationMessage,
+};

package/scripts/feedback-root-consolidator.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+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 ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: 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 readJsonlFile(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return [];
+  const raw = fs.readFileSync(filePath, 'utf8').trim();
+  if (!raw) return [];
+  return raw
+    .split('\n')
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+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) => readJsonlFile(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 feedbackDir = options.feedbackDir
+    || process.env.THUMBGATE_FEEDBACK_DIR
+    || getThumbgateFeedbackDir(options);
+  const artifacts = CONSOLIDATED_ARTIFACTS.map((fileName) => consolidateArtifact(fileName, {
+    ...options,
+    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,
+  mergeCheckoutSessionsPayloads,
+  mergeKeyStorePayloads,
+};
+
+if (require.main === module) {
+  runCli();
+}