thumbgate 1.4.3 → 1.4.5

package/scripts/pr-manager.js

@@ -1,421 +0,0 @@
-#!/usr/bin/env node
-/**
- * PR Manager — High-Throughput Merge & Blocker Diagnosis
- * 
- * Inspired by the 2026 GitHub 'Quick Access' update. Centralizes merge status 
- * detection and triggers autonomous self-healing for common blockers.
- */
-
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-const PR_FIELDS = 'number,state,mergeable,mergeStateStatus,statusCheckRollup,reviewDecision,isDraft,title,url,headRefOid,baseRefName,mergeCommit,mergedAt,mergedBy';
-const PR_CHECK_FIELDS = 'bucket,name,state,workflow,link,event';
-const MERGE_QUALITY_CHECKS = JSON.parse(
-  fs.readFileSync(path.join(__dirname, '..', 'config', 'merge-quality-checks.json'), 'utf8')
-);
-const FIXED_GH_BINARIES = [
-  '/usr/bin/gh',
-  '/usr/local/bin/gh',
-  '/opt/homebrew/bin/gh',
-];
-const SUCCESSFUL_CHECK_CONCLUSIONS = new Set(['SUCCESS', 'SKIPPED', 'NEUTRAL']);
-const FAILING_CHECK_CONCLUSIONS = new Set([
-  'ACTION_REQUIRED',
-  'CANCELLED',
-  'FAILURE',
-  'STALE',
-  'STARTUP_FAILURE',
-  'TIMED_OUT',
-]);
-const PASSING_BUCKETS = new Set((MERGE_QUALITY_CHECKS.passingBuckets || []).map((value) => String(value || '').toLowerCase()));
-const PENDING_BUCKETS = new Set((MERGE_QUALITY_CHECKS.pendingBuckets || []).map((value) => String(value || '').toLowerCase()));
-const FAILING_BUCKETS = new Set((MERGE_QUALITY_CHECKS.failingBuckets || []).map((value) => String(value || '').toLowerCase()));
-
-function assertSafeGhArgs(args) {
-  if (!Array.isArray(args) || args.length === 0) {
-    throw new Error('GH CLI args must be a non-empty array.');
-  }
-
-  return args.map((arg) => {
-    const normalized = String(arg ?? '');
-    if (!normalized || /\0/.test(normalized)) {
-      throw new Error(`Unsafe GH CLI arg: ${arg}`);
-    }
-    return normalized;
-  });
-}
-
-function normalizePrNumber(prNumber, { allowEmpty = true } = {}) {
-  const normalized = String(prNumber ?? '').trim();
-  if (!normalized) {
-    if (allowEmpty) {
-      return '';
-    }
-    throw new Error('PR number is required.');
-  }
-
-  if (!/^[1-9]\d*$/.test(normalized)) {
-    throw new Error(`Unsafe PR number: ${prNumber}`);
-  }
-
-  return normalized;
-}
-
-function resolveGhBinary(options = {}) {
-  const accessSync = options.accessSync || fs.accessSync;
-  const candidates = [];
-  const configuredBinary = String(process.env.THUMBGATE_GH_BIN || '').trim();
-
-  if (configuredBinary) {
-    if (!path.isAbsolute(configuredBinary)) {
-      throw new Error(`Unsafe GH binary path: ${configuredBinary}`);
-    }
-    candidates.push(configuredBinary);
-  }
-
-  candidates.push(...FIXED_GH_BINARIES);
-
-  for (const candidate of candidates) {
-    try {
-      accessSync(candidate, fs.constants.X_OK);
-      return candidate;
-    } catch {
-      continue;
-    }
-  }
-
-  throw new Error(`Unable to locate GH CLI in fixed paths: ${candidates.join(', ')}`);
-}
-
-function runGh(args, options = {}) {
-  return spawnSync(resolveGhBinary(options), assertSafeGhArgs(args), {
-    encoding: 'utf-8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-}
-
-function formatGhError(result) {
-  return (result.stderr || result.stdout || 'Unknown GH CLI failure').trim();
-}
-
-function isMissingCurrentBranchPr(result, prNumber) {
-  if (prNumber) {
-    return false;
-  }
-
-  return /no pull requests found for branch/i.test(formatGhError(result));
-}
-
-/**
- * Fetch granular PR status using GH CLI
- */
-function getPrStatus(prNumber = '', runner = runGh) {
-  const normalizedPrNumber = normalizePrNumber(prNumber);
-  const args = ['pr', 'view'];
-  if (normalizedPrNumber) args.push(normalizedPrNumber);
-  args.push('--json', PR_FIELDS);
-
-  const result = runner(args);
-  if (result.status !== 0) {
-    if (isMissingCurrentBranchPr(result, normalizedPrNumber)) {
-      return null;
-    }
-
-    throw new Error(`Failed to fetch PR status: ${formatGhError(result)}`);
-  }
-  return JSON.parse(result.stdout);
-}
-
-function getPrChecks(prNumber = '', runner = runGh) {
-  const normalizedPrNumber = normalizePrNumber(prNumber, { allowEmpty: false });
-  const result = runner(['pr', 'checks', normalizedPrNumber, '--json', PR_CHECK_FIELDS]);
-  if (result.status !== 0) {
-    throw new Error(`Failed to fetch PR checks: ${formatGhError(result)}`);
-  }
-
-  return JSON.parse(result.stdout || '[]');
-}
-
-function listOpenPrs(runner = runGh) {
-  const result = runner(['pr', 'list', '--state', 'open', '--json', PR_FIELDS]);
-  if (result.status !== 0) {
-    throw new Error(`Failed to list open PRs: ${formatGhError(result)}`);
-  }
-
-  return JSON.parse(result.stdout || '[]');
-}
-
-function isOpenPr(pr) {
-  return Boolean(pr) && String(pr.state || 'OPEN').toUpperCase() === 'OPEN';
-}
-
-function loadManagedPrs(prNumber = '', runner = runGh) {
-  if (prNumber) {
-    return [getPrStatus(prNumber, runner)];
-  }
-
-  const currentBranchPr = getPrStatus('', runner);
-  if (isOpenPr(currentBranchPr)) {
-    return [currentBranchPr];
-  }
-
-  return listOpenPrs(runner);
-}
-
-function summarizeChecks(checks = []) {
-  const failing = [];
-  const pending = [];
-
-  for (const check of checks) {
-    const name = check.name || 'unknown-check';
-    const bucket = String(check.bucket || '').toLowerCase();
-    if (bucket) {
-      if (FAILING_BUCKETS.has(bucket)) {
-        failing.push(name);
-        continue;
-      }
-
-      if (PENDING_BUCKETS.has(bucket)) {
-        pending.push(name);
-        continue;
-      }
-
-      if (PASSING_BUCKETS.has(bucket)) {
-        continue;
-      }
-    }
-
-    const conclusion = check.conclusion || null;
-    const status = check.status || (conclusion ? 'COMPLETED' : 'UNKNOWN');
-
-    if (status !== 'COMPLETED') {
-      pending.push(name);
-      continue;
-    }
-
-    if (conclusion && FAILING_CHECK_CONCLUSIONS.has(conclusion)) {
-      failing.push(name);
-      continue;
-    }
-
-    if (conclusion && !SUCCESSFUL_CHECK_CONCLUSIONS.has(conclusion)) {
-      pending.push(name);
-    }
-  }
-
-  return { failing, pending };
-}
-
-function sleep(ms) {
-  if (!ms || ms <= 0) return;
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
-/**
- * Diagnose and resolve blockers autonomously
- */
-async function resolveBlockers(pr, runner = runGh) {
-  const title = pr.title || 'Untitled PR';
-  const mergeState = pr.mergeStateStatus || 'UNKNOWN';
-  const mergeable = pr.mergeable || 'UNKNOWN';
-
-  console.log(`[PR Manager] Diagnosing PR #${pr.number}: "${title}"`);
-  console.log(`[PR Manager] Merge State: ${mergeState} | Mergeable: ${mergeable}`);
-
-  if (pr.isDraft) {
-    console.log('[PR Manager] PR is a draft. Skipping.');
-    return { status: 'skipped', reason: 'draft' };
-  }
-
-  // 1. Handle Outdated Branch (BEHIND)
-  if (pr.mergeStateStatus === 'BEHIND') {
-    console.log('[PR Manager] PR is behind main. Triggering auto-update...');
-    const update = runner(['pr', 'update-branch', pr.number.toString()]);
-    if (update.status === 0) {
-      return { status: 'healing', action: 'update-branch' };
-    }
-  }
-
-  // 2. Handle Merge Conflicts (DIRTY)
-  if (pr.mergeStateStatus === 'DIRTY' || pr.mergeable === 'CONFLICTING') {
-    console.log('[PR Manager] CRITICAL: Merge conflicts detected. Manual intervention or advanced rebase required.');
-    return { status: 'blocked', reason: 'conflicts' };
-  }
-
-  // 3. Handle CI Failures
-  let checks = pr.statusCheckRollup || [];
-  let checkSource = 'statusCheckRollup';
-
-  if (pr.number) {
-    try {
-      checks = getPrChecks(pr.number, runner);
-      checkSource = 'gh pr checks';
-    } catch (error) {
-      console.warn(`[PR Manager] Falling back to statusCheckRollup for PR #${pr.number}: ${error.message}`);
-    }
-  }
-
-  const checkSummary = summarizeChecks(checks);
-  const failingChecks = checkSummary.failing;
-
-  if (failingChecks.length > 0) {
-    console.log(`[PR Manager] BLOCKED: ${failingChecks.length} failing quality checks via ${checkSource}.`);
-    return { status: 'blocked', reason: 'ci_failure', checks: failingChecks, checkSource };
-  }
-
-  if (checkSummary.pending.length > 0) {
-    console.log(`[PR Manager] BLOCKED: ${checkSummary.pending.length} quality checks still pending via ${checkSource}.`);
-    return { status: 'blocked', reason: 'ci_pending', checks: checkSummary.pending, checkSource };
-  }
-
-  // 4. Handle Review Blockers
-  if (pr.reviewDecision === 'CHANGES_REQUESTED') {
-    console.log('[PR Manager] BLOCKED: Changes requested by reviewer.');
-    return { status: 'blocked', reason: 'changes_requested' };
-  }
-
-  if (pr.reviewDecision === 'REVIEW_REQUIRED') {
-    console.log('[PR Manager] BLOCKED: Required review is still outstanding.');
-    return { status: 'blocked', reason: 'review_required' };
-  }
-
-  // 5. Ready to Merge
-  if (pr.mergeStateStatus === 'CLEAN' && pr.mergeable === 'MERGEABLE') {
-    console.log('[PR Manager] SUCCESS: PR is ready for protected autonomous merge.');
-    return { status: 'ready' };
-  }
-
-  return { status: 'pending', reason: 'unknown_state' };
-}
-
-function waitForMergeCommit(prNumber, runner = runGh, options = {}) {
-  const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 300000;
-  const intervalMs = Number.isFinite(options.intervalMs) ? options.intervalMs : 10000;
-  const startedAt = Date.now();
-
-  do {
-    const pr = getPrStatus(prNumber, runner);
-    if (pr && String(pr.state || '').toUpperCase() === 'MERGED' && pr.mergeCommit && pr.mergeCommit.oid) {
-      return {
-        finalized: true,
-        merged: true,
-        mergeCommit: pr.mergeCommit.oid,
-        mergedAt: pr.mergedAt || null,
-        mergedBy: pr.mergedBy && pr.mergedBy.login ? pr.mergedBy.login : null,
-        pr,
-      };
-    }
-
-    if (pr && String(pr.state || '').toUpperCase() === 'CLOSED') {
-      return {
-        finalized: true,
-        merged: false,
-        reason: 'closed_without_merge',
-        pr,
-      };
-    }
-
-    if (intervalMs <= 0) {
-      break;
-    }
-
-    if ((Date.now() - startedAt + intervalMs) > timeoutMs) {
-      break;
-    }
-
-    sleep(intervalMs);
-  } while ((Date.now() - startedAt) <= timeoutMs);
-
-  return {
-    finalized: false,
-    merged: false,
-    reason: 'merge_commit_pending',
-  };
-}
-
-/**
- * Perform autonomous merge
- */
-function performMerge(prNumber, runner = runGh, options = {}) {
-  const normalizedPrNumber = normalizePrNumber(prNumber, { allowEmpty: false });
-  const args = ['pr', 'merge', normalizedPrNumber, '--squash', '--delete-branch'];
-  console.log(`[PR Manager] Initiating protected squash merge for PR #${normalizedPrNumber}...`);
-  const result = runner(args);
-  if (result.status === 0) {
-    const output = `${result.stdout || ''}\n${result.stderr || ''}`;
-    const mode = /merge queue|queued/i.test(output) ? 'queued' : 'merged';
-    console.log(`[PR Manager] Merge accepted for PR #${normalizedPrNumber} (${mode}).`);
-    const mergeStatus = options.waitForMerge === false
-      ? { finalized: false, merged: false, reason: 'merge_commit_pending' }
-      : waitForMergeCommit(normalizedPrNumber, runner, options);
-    return { ok: true, mode, args, ...mergeStatus };
-  } else {
-    console.error(`[PR Manager] Merge failed: ${formatGhError(result)}`);
-    return { ok: false, mode: 'failed', args, error: formatGhError(result) };
-  }
-}
-
-async function managePrs(prNumber = '', runner = runGh, options = {}) {
-  const prs = loadManagedPrs(prNumber, runner).filter(Boolean);
-
-  if (prs.length === 0) {
-    console.log('[PR Manager] No open pull requests found.');
-    return { status: 'noop', prs: [] };
-  }
-
-  const results = [];
-  for (const pr of prs) {
-    const outcome = await resolveBlockers(pr, runner);
-    if (outcome.status === 'ready') {
-      const mergeResult = performMerge(pr.number, runner, options);
-      outcome.mergeRequested = mergeResult.ok;
-      outcome.mergeMode = mergeResult.mode;
-      if (mergeResult.mergeCommit) {
-        outcome.mergeCommit = mergeResult.mergeCommit;
-      }
-      if (mergeResult.finalized !== undefined) {
-        outcome.mergeFinalized = mergeResult.finalized;
-      }
-      if (mergeResult.reason) {
-        outcome.mergeResolution = mergeResult.reason;
-      }
-    }
-
-    results.push({
-      number: pr.number,
-      title: pr.title,
-      outcome,
-    });
-  }
-
-  return { status: 'ok', prs: results };
-}
-
-if (require.main === module) {
-  const prNum = process.argv[2];
-  managePrs(prNum).then(() => {
-    process.exit(0);
-  }).catch((err) => {
-    console.error(err.message);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  assertSafeGhArgs,
-  getPrStatus,
-  getPrChecks,
-  listOpenPrs,
-  isOpenPr,
-  loadManagedPrs,
-  normalizePrNumber,
-  resolveBlockers,
-  resolveGhBinary,
-  waitForMergeCommit,
-  performMerge,
-  managePrs,
-  summarizeChecks,
-};

package/scripts/principle-extractor.js

@@ -1,162 +0,0 @@
-'use strict';
-
-/**
- * MemAlign-style principle extraction from NL feedback.
- *
- * Distills whatWentWrong / whatToChange / whatWorked into reusable
- * NEVER/ALWAYS semantic principles stored in principles.jsonl.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { getFeedbackPaths, readJSONL, inferDomain } = require('./feedback-loop');
-
-const PRINCIPLES_FILENAME = 'principles.jsonl';
-
-/**
- * Extract a semantic principle from a single feedback entry.
- *
- * @param {object} entry - A feedback log entry.
- * @returns {object|null} A principle object or null if nothing extractable.
- */
-function extractPrinciple(entry) {
-  if (!entry) return null;
-
-  const signal = String(entry.signal || '').toLowerCase();
-  const isNegative = ['negative', 'down', 'thumbs-down', 'thumbsdown'].includes(signal);
-  const isPositive = ['positive', 'up', 'thumbs-up', 'thumbsup'].includes(signal);
-
-  if (!isNegative && !isPositive) return null;
-
-  const tags = Array.isArray(entry.tags) ? entry.tags : [];
-  const domain = inferDomain(tags, entry.context || '');
-
-  if (isNegative) {
-    const wrong = (entry.whatWentWrong || '').trim();
-    const change = (entry.whatToChange || '').trim();
-    if (!wrong && !change) return null;
-
-    const text = change
-      ? `NEVER: ${wrong || change}. INSTEAD: ${change}`
-      : `NEVER: ${wrong}`;
-
-    return {
-      id: `prin_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      type: 'constraint',
-      polarity: 'negative',
-      text,
-      source: wrong,
-      correction: change || null,
-      tags,
-      domain,
-      sourceCount: 1,
-      createdAt: new Date().toISOString(),
-    };
-  }
-
-  // Positive
-  const worked = (entry.whatWorked || '').trim();
-  if (!worked) return null;
-
-  return {
-    id: `prin_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-    type: 'heuristic',
-    polarity: 'positive',
-    text: `ALWAYS: ${worked}`,
-    source: worked,
-    correction: null,
-    tags,
-    domain,
-    sourceCount: 1,
-    createdAt: new Date().toISOString(),
-  };
-}
-
-/**
- * Batch-extract principles from a feedback log, deduplicating by text.
- *
- * @param {string} [logPath] - Path to feedback-log.jsonl.
- * @param {string} [principlesPath] - Path to write principles.jsonl.
- * @returns {{ created: number, updated: number, total: number }}
- */
-function extractAllPrinciples(logPath, principlesPath) {
-  const paths = getFeedbackPaths();
-  const feedbackLog = logPath || paths.FEEDBACK_LOG_PATH;
-  const outPath = principlesPath || path.join(path.dirname(feedbackLog), PRINCIPLES_FILENAME);
-
-  const entries = readJSONL(feedbackLog);
-  const existing = readJSONL(outPath);
-
-  // Index existing by normalized text for dedup
-  const byText = new Map();
-  for (const p of existing) {
-    if (p && p.text) byText.set(p.text, p);
-  }
-
-  let created = 0;
-  let updated = 0;
-
-  for (const entry of entries) {
-    const principle = extractPrinciple(entry);
-    if (!principle) continue;
-
-    const match = byText.get(principle.text);
-    if (match) {
-      match.sourceCount = (match.sourceCount || 1) + 1;
-      updated++;
-    } else {
-      byText.set(principle.text, principle);
-      created++;
-    }
-  }
-
-  // Write all principles
-  const dir = path.dirname(outPath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const lines = [...byText.values()].map((p) => JSON.stringify(p)).join('\n');
-  fs.writeFileSync(outPath, lines ? `${lines}\n` : '');
-
-  return { created, updated, total: byText.size };
-}
-
-/**
- * Retrieve principles with optional filtering.
- *
- * @param {object} opts
- * @param {string[]} [opts.tags] - Filter by tags (any match).
- * @param {string}   [opts.domain] - Filter by domain.
- * @param {number}   [opts.limit] - Max results.
- * @param {string}   [opts.principlesPath] - Path to principles.jsonl.
- * @returns {object[]} Matching principles.
- */
-function getPrinciples({ tags, domain, limit, principlesPath } = {}) {
-  const paths = getFeedbackPaths();
-  const filePath = principlesPath || path.join(paths.FEEDBACK_DIR, PRINCIPLES_FILENAME);
-  const all = readJSONL(filePath);
-
-  let results = all;
-
-  if (tags && tags.length > 0) {
-    const tagSet = new Set(tags.map((t) => t.toLowerCase()));
-    results = results.filter((p) =>
-      Array.isArray(p.tags) && p.tags.some((t) => tagSet.has(t.toLowerCase()))
-    );
-  }
-
-  if (domain) {
-    results = results.filter((p) => p.domain === domain);
-  }
-
-  if (typeof limit === 'number' && limit > 0) {
-    results = results.slice(0, limit);
-  }
-
-  return results;
-}
-
-module.exports = {
-  PRINCIPLES_FILENAME,
-  extractPrinciple,
-  extractAllPrinciples,
-  getPrinciples,
-};

package/scripts/pro-features.js

@@ -1,41 +0,0 @@
-'use strict';
-const { isProLicensed } = require('./license');
-const {
-  PRO_MONTHLY_PAYMENT_LINK,
-  PRO_PRICE_LABEL,
-  TEAM_PRICE_LABEL,
-} = require('./commercial-offer');
-
-const PRO_URL = PRO_MONTHLY_PAYMENT_LINK;
-
-function requirePro(
-  featureName,
-  {
-    isProLicensedFn = isProLicensed,
-    write = (message) => process.stderr.write(message),
-  } = {}
-) {
-  if (isProLicensedFn()) return true;
-  const descriptions = {
-    'dpo-export': 'Export feedback as DPO training pairs for model fine-tuning',
-    'dpo-synthesis': 'Generate synthetic DPO pairs from existing feedback patterns',
-    'multi-hop-recall': 'Multi-hop recall — chain related lessons for deeper context',
-    'databricks-export': 'Export to Databricks ML pipeline format',
-    'dashboard-search': 'Search, filter, and edit lessons across all repos',
-    'multi-repo-sync': 'Sync prevention rules across multiple repositories',
-    'custom-gates': 'Create custom pre-action gates beyond the defaults',
-    'advanced-thompson': 'Advanced Thompson Sampling with custom priors and decay',
-    'rule-analytics': 'Analytics on which rules fire most and their block rates',
-    'team-sharing': 'Share lesson databases across team members',
-  };
-  const desc = descriptions[featureName] || featureName;
-  write(
-    `\n  🔒 Pro Feature Required: ${desc}\n` +
-    `     Pro: ${PRO_PRICE_LABEL} — ${PRO_URL}\n` +
-    `     Team: ${TEAM_PRICE_LABEL} after workflow qualification\n` +
-    `     Or run: npx thumbgate pro\n\n`
-  );
-  return false;
-}
-
-module.exports = { requirePro, PRO_URL };