thumbgate 1.4.3 → 1.4.5

package/scripts/status-dashboard.js

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-/**
- * Status Dashboard
- *
- * CLI dashboard that reads feedback data and outputs a learning curve summary.
- *
- * Usage:
- *   node scripts/status-dashboard.js
- *
- * Exports:
- *   generateStatus(feedbackDir) — returns status object with approval rates,
- *   trends, failure domains, memory count, prevention rule count, and learning curve.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { getFeedbackPaths, readJSONL } = require('./feedback-loop');
-
-function generateStatus(feedbackDir) {
-  const feedbackLogPath = path.join(feedbackDir, 'feedback-log.jsonl');
-  const memoryLogPath = path.join(feedbackDir, 'memory-log.jsonl');
-  const preventionRulesPath = path.join(feedbackDir, 'prevention-rules.md');
-
-  const entries = readJSONL(feedbackLogPath);
-  const totalSignals = entries.length;
-  const positive = entries.filter((e) => e.signal === 'positive').length;
-  const negative = entries.filter((e) => e.signal === 'negative').length;
-  const approvalRate = totalSignals > 0 ? Math.round((positive / totalSignals) * 100) : 0;
-
-  // Recent approval rate (last 20)
-  const recentWindow = 20;
-  const recent = entries.slice(-recentWindow);
-  const recentPositive = recent.filter((e) => e.signal === 'positive').length;
-  const recentApprovalRate = recent.length > 0 ? Math.round((recentPositive / recent.length) * 100) : 0;
-
-  // Trend
-  let trend = 'stable';
-  if (totalSignals >= recentWindow) {
-    const diff = recentApprovalRate - approvalRate;
-    if (diff > 5) trend = 'improving';
-    else if (diff < -5) trend = 'declining';
-  }
-
-  // Top failure domains
-  const domainCounts = {};
-  entries
-    .filter((e) => e.signal === 'negative')
-    .forEach((e) => {
-      const domain = (e.richContext && e.richContext.domain) || inferDomainFromTags(e.tags);
-      domainCounts[domain] = (domainCounts[domain] || 0) + 1;
-    });
-  const topFailureDomains = Object.entries(domainCounts)
-    .map(([domain, count]) => ({ domain, count }))
-    .sort((a, b) => b.count - a.count);
-
-  // Memory count
-  const memoryEntries = readJSONL(memoryLogPath);
-  const memoryCount = memoryEntries.length;
-
-  // Prevention rule count
-  let preventionRuleCount = 0;
-  if (fs.existsSync(preventionRulesPath)) {
-    const rulesContent = fs.readFileSync(preventionRulesPath, 'utf-8');
-    const ruleHeaders = rulesContent.match(/^## /gm);
-    preventionRuleCount = ruleHeaders ? ruleHeaders.length : 0;
-  }
-
-  // Learning curve — sliding windows of 10
-  const learningCurve = [];
-  const windowSize = 10;
-  for (let i = 0; i + windowSize <= entries.length; i++) {
-    const window = entries.slice(i, i + windowSize);
-    const windowPositive = window.filter((e) => e.signal === 'positive').length;
-    const windowRate = Math.round((windowPositive / windowSize) * 100);
-    learningCurve.push({ window: i, approvalRate: windowRate });
-  }
-
-  return {
-    totalSignals,
-    positive,
-    negative,
-    approvalRate,
-    recentApprovalRate,
-    trend,
-    topFailureDomains,
-    memoryCount,
-    preventionRuleCount,
-    learningCurve,
-  };
-}
-
-function inferDomainFromTags(tags) {
-  if (!Array.isArray(tags) || tags.length === 0) return 'general';
-  const tagSet = new Set(tags.map((t) => t.toLowerCase()));
-  if (tagSet.has('testing') || tagSet.has('test')) return 'testing';
-  if (tagSet.has('security')) return 'security';
-  if (tagSet.has('performance') || tagSet.has('perf')) return 'performance';
-  if (tagSet.has('ui') || tagSet.has('component')) return 'ui-components';
-  if (tagSet.has('api') || tagSet.has('endpoint')) return 'api-integration';
-  if (tagSet.has('git') || tagSet.has('commit')) return 'git-workflow';
-  if (tagSet.has('doc') || tagSet.has('readme')) return 'documentation';
-  if (tagSet.has('debug') || tagSet.has('debugging')) return 'debugging';
-  if (tagSet.has('arch') || tagSet.has('architecture')) return 'architecture';
-  if (tagSet.has('data') || tagSet.has('schema')) return 'data-modeling';
-  return 'general';
-}
-
-function printDashboard(status) {
-  console.log('╔══════════════════════════════════════════╗');
-  console.log('║      Feedback Tracking Dashboard          ║');
-  console.log('╠══════════════════════════════════════════╣');
-  console.log(`║  Total Signals:     ${String(status.totalSignals).padStart(6)}              ║`);
-  console.log(`║  Positive:          ${String(status.positive).padStart(6)}              ║`);
-  console.log(`║  Negative:          ${String(status.negative).padStart(6)}              ║`);
-  console.log(`║  Approval Rate:     ${String(status.approvalRate + '%').padStart(6)}              ║`);
-  console.log(`║  Recent (last 20):  ${String(status.recentApprovalRate + '%').padStart(6)}              ║`);
-  console.log(`║  Trend:             ${status.trend.padStart(6)}              ║`);
-  console.log(`║  Memories:          ${String(status.memoryCount).padStart(6)}              ║`);
-  console.log(`║  Prevention Rules:  ${String(status.preventionRuleCount).padStart(6)}              ║`);
-  console.log('╠══════════════════════════════════════════╣');
-
-  if (status.topFailureDomains.length > 0) {
-    console.log('║  Top Failure Domains:                    ║');
-    status.topFailureDomains.slice(0, 5).forEach((d) => {
-      const line = `    ${d.domain}: ${d.count}`;
-      console.log(`║  ${line.padEnd(38)}║`);
-    });
-  } else {
-    console.log('║  No failure domains recorded             ║');
-  }
-
-  console.log('╠══════════════════════════════════════════╣');
-  console.log('║  Feedback Trend:                         ║');
-  if (status.learningCurve.length > 0) {
-    const step = Math.max(1, Math.floor(status.learningCurve.length / 5));
-    for (let i = 0; i < status.learningCurve.length; i += step) {
-      const point = status.learningCurve[i];
-      const bar = '█'.repeat(Math.floor(point.approvalRate / 5));
-      const line = `    w${String(point.window).padStart(3)}: ${bar} ${point.approvalRate}%`;
-      console.log(`║  ${line.padEnd(38)}║`);
-    }
-  } else {
-    console.log('║  Not enough data for feedback trend      ║');
-  }
-
-  console.log('╚══════════════════════════════════════════╝');
-}
-
-if (require.main === module) {
-  const { FEEDBACK_DIR } = getFeedbackPaths();
-  const status = generateStatus(FEEDBACK_DIR);
-  printDashboard(status);
-}
-
-module.exports = { generateStatus, printDashboard };

package/scripts/stripe-live-status.js

@@ -1,115 +0,0 @@
-#!/usr/bin/env node
-/**
- * stripe-live-status.js — Pull live financial data from Stripe API.
- * Shows real revenue, not local ledger approximations.
- */
-
-'use strict';
-
-const Stripe = require('stripe');
-
-const STRIPE_SECRET_KEY = process.env.STRIPE_SECRET_KEY;
-
-if (!STRIPE_SECRET_KEY) {
-  console.error('STRIPE_SECRET_KEY not set');
-  process.exit(1);
-}
-
-const stripe = new Stripe(STRIPE_SECRET_KEY);
-
-async function getLiveStatus() {
-  const [balance, charges, subscriptions, products, prices, sessions] = await Promise.all([
-    stripe.balance.retrieve(),
-    stripe.charges.list({ limit: 100 }),
-    stripe.subscriptions.list({ limit: 100, status: 'all' }),
-    stripe.products.list({ limit: 20, active: true }),
-    stripe.prices.list({ limit: 20, active: true }),
-    stripe.checkout.sessions.list({ limit: 50 }),
-  ]);
-
-  const availableBalance = balance.available.reduce((sum, b) => sum + b.amount, 0);
-  const pendingBalance = balance.pending.reduce((sum, b) => sum + b.amount, 0);
-
-  const paidCharges = charges.data.filter(c => c.paid && !c.refunded);
-  const refundedCharges = charges.data.filter(c => c.refunded);
-  const failedCharges = charges.data.filter(c => c.status === 'failed');
-
-  const grossRevenue = paidCharges.reduce((sum, c) => sum + c.amount, 0);
-  const refundedAmount = refundedCharges.reduce((sum, c) => sum + c.amount_refunded, 0);
-
-  const activeSubs = subscriptions.data.filter(s => s.status === 'active');
-  const cancelledSubs = subscriptions.data.filter(s => s.status === 'canceled');
-
-  const completedSessions = sessions.data.filter(s => s.payment_status === 'paid');
-  const expiredSessions = sessions.data.filter(s => s.status === 'expired');
-
-  const todayStart = new Date();
-  todayStart.setHours(0, 0, 0, 0);
-  const todayCharges = paidCharges.filter(c => c.created * 1000 >= todayStart.getTime());
-  const todayRevenue = todayCharges.reduce((sum, c) => sum + c.amount, 0);
-
-  const report = {
-    generatedAt: new Date().toISOString(),
-    source: 'stripe_live_api',
-    balance: {
-      available: availableBalance / 100,
-      pending: pendingBalance / 100,
-      currency: 'USD',
-    },
-    revenue: {
-      grossLifetime: grossRevenue / 100,
-      refundedLifetime: refundedAmount / 100,
-      netLifetime: (grossRevenue - refundedAmount) / 100,
-      today: todayRevenue / 100,
-      todayChargeCount: todayCharges.length,
-    },
-    charges: {
-      total: charges.data.length,
-      paid: paidCharges.length,
-      refunded: refundedCharges.length,
-      failed: failedCharges.length,
-    },
-    subscriptions: {
-      active: activeSubs.length,
-      cancelled: cancelledSubs.length,
-      total: subscriptions.data.length,
-      mrr: activeSubs.reduce((sum, s) => sum + (s.plan?.amount || 0), 0) / 100,
-    },
-    checkout: {
-      completed: completedSessions.length,
-      expired: expiredSessions.length,
-      total: sessions.data.length,
-      conversionRate: sessions.data.length > 0
-        ? (completedSessions.length / sessions.data.length * 100).toFixed(1) + '%'
-        : '0%',
-    },
-    products: products.data.map(p => ({
-      id: p.id,
-      name: p.name,
-      defaultPrice: p.default_price,
-    })),
-    activePrices: prices.data.map(p => ({
-      id: p.id,
-      amount: p.unit_amount / 100,
-      type: p.type,
-      interval: p.recurring?.interval || 'one_time',
-      product: p.product,
-    })),
-  };
-
-  return report;
-}
-
-async function main() {
-  const report = await getLiveStatus();
-  console.log(JSON.stringify(report, null, 2));
-}
-
-if (require.main === module) {
-  main().catch(err => {
-    console.error('Stripe live status failed:', err.message);
-    process.exit(1);
-  });
-}
-
-module.exports = { getLiveStatus };

package/scripts/subagent-profiles.js

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-const { loadMcpPolicy } = require('./mcp-policy');
-
-const PROJECT_ROOT = path.join(__dirname, '..');
-const DEFAULT_SUBAGENT_PROFILE_PATH = path.join(PROJECT_ROOT, 'config', 'subagent-profiles.json');
-
-function getSubagentProfilePath() {
-  return process.env.THUMBGATE_SUBAGENT_PROFILE_PATH || DEFAULT_SUBAGENT_PROFILE_PATH;
-}
-
-function loadSubagentProfiles() {
-  const raw = fs.readFileSync(getSubagentProfilePath(), 'utf-8');
-  const parsed = JSON.parse(raw);
-  if (!parsed.profiles || typeof parsed.profiles !== 'object') {
-    throw new Error('Invalid subagent profile config: missing profiles object');
-  }
-  return parsed;
-}
-
-function listSubagentProfiles() {
-  const parsed = loadSubagentProfiles();
-  return Object.keys(parsed.profiles);
-}
-
-function getSubagentProfile(name) {
-  const parsed = loadSubagentProfiles();
-  const profile = parsed.profiles[name];
-  if (!profile) {
-    throw new Error(`Unknown subagent profile: ${name}`);
-  }
-  return profile;
-}
-
-function validateSubagentProfiles() {
-  const parsed = loadSubagentProfiles();
-  const policy = loadMcpPolicy();
-  const issues = [];
-
-  for (const [name, profile] of Object.entries(parsed.profiles)) {
-    if (!profile.mcpProfile) {
-      issues.push(`${name}: missing mcpProfile`);
-    } else if (!policy.profiles[profile.mcpProfile]) {
-      issues.push(`${name}: unknown mcpProfile '${profile.mcpProfile}'`);
-    }
-
-    if (!profile.context || typeof profile.context !== 'object') {
-      issues.push(`${name}: missing context settings`);
-    } else {
-      if (!Number.isFinite(profile.context.maxItems) || profile.context.maxItems <= 0) {
-        issues.push(`${name}: invalid context.maxItems`);
-      }
-      if (!Number.isFinite(profile.context.maxChars) || profile.context.maxChars <= 0) {
-        issues.push(`${name}: invalid context.maxChars`);
-      }
-    }
-  }
-
-  return {
-    valid: issues.length === 0,
-    issues,
-  };
-}
-
-module.exports = {
-  DEFAULT_SUBAGENT_PROFILE_PATH,
-  getSubagentProfilePath,
-  loadSubagentProfiles,
-  listSubagentProfiles,
-  getSubagentProfile,
-  validateSubagentProfiles,
-};
-
-if (require.main === module) {
-  const result = validateSubagentProfiles();
-  console.log(JSON.stringify({ profiles: listSubagentProfiles(), ...result }, null, 2));
-  process.exit(result.valid ? 0 : 1);
-}

package/scripts/sync-branch-protection.js

@@ -1,340 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-const MERGE_QUALITY_CHECKS = require('../config/merge-quality-checks.json');
-
-const DEFAULT_REPO = process.env.GITHUB_REPOSITORY || 'IgorGanapolsky/ThumbGate';
-const DEFAULT_BRANCH = process.env.DEFAULT_BRANCH || 'main';
-const FIXED_GH_BINARIES = [
-  '/usr/bin/gh',
-  '/usr/local/bin/gh',
-  '/opt/homebrew/bin/gh',
-];
-
-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 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 = {}) {
-  const env = { ...process.env };
-  if (!env.GITHUB_ACTIONS && env.GITHUB_TOKEN && !env.GH_TOKEN) {
-    delete env.GITHUB_TOKEN;
-  }
-
-  return spawnSync(resolveGhBinary(options), assertSafeGhArgs(args), {
-    encoding: 'utf8',
-    env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-}
-
-function formatGhError(result) {
-  return (result.stderr || result.stdout || 'Unknown GH CLI failure').trim();
-}
-
-function parseArgs(argv = process.argv.slice(2)) {
-  const options = {
-    check: false,
-    json: false,
-    repo: DEFAULT_REPO,
-    branch: DEFAULT_BRANCH,
-  };
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === '--check') {
-      options.check = true;
-    } else if (arg === '--json') {
-      options.json = true;
-    } else if (arg === '--repo' && argv[index + 1]) {
-      options.repo = argv[index + 1];
-      index += 1;
-    } else if (arg === '--branch' && argv[index + 1]) {
-      options.branch = argv[index + 1];
-      index += 1;
-    }
-  }
-
-  return options;
-}
-
-function assertSafeRepoSegment(value, label) {
-  const normalized = String(value || '').trim();
-  if (!/^[A-Za-z0-9_.-]+$/.test(normalized)) {
-    throw new Error(`Unsafe repository ${label}: ${value}`);
-  }
-  return normalized;
-}
-
-function splitRepo(repo) {
-  const [owner, name] = String(repo || '').trim().split('/');
-  if (!owner || !name) {
-    throw new Error(`Invalid repository "${repo}". Expected owner/name.`);
-  }
-  return {
-    owner: assertSafeRepoSegment(owner, 'owner'),
-    name: assertSafeRepoSegment(name, 'name'),
-  };
-}
-
-function assertSafeBranchPattern(branch) {
-  const normalized = String(branch || '').trim();
-  if (!normalized) {
-    throw new Error('Branch pattern is required.');
-  }
-  if (normalized.startsWith('-') || normalized.includes('..') || normalized.includes('//') || normalized.includes('@{')) {
-    throw new Error(`Unsafe branch pattern: ${branch}`);
-  }
-  if (normalized.endsWith('.') || normalized.endsWith('/')) {
-    throw new Error(`Unsafe branch pattern: ${branch}`);
-  }
-  if (!/^[A-Za-z0-9._/-]+$/.test(normalized)) {
-    throw new Error(`Unsafe branch pattern: ${branch}`);
-  }
-  return normalized;
-}
-
-function assertSafeRuleId(ruleId) {
-  const normalized = String(ruleId || '').trim();
-  if (!/^[A-Za-z0-9_=-]+$/.test(normalized)) {
-    throw new Error(`Unsafe branch protection rule id: ${ruleId}`);
-  }
-  return normalized;
-}
-
-function assertSafeStatusContext(context) {
-  const normalized = String(context || '').trim();
-  if (!normalized || /[\0\r\n]/.test(normalized)) {
-    throw new Error(`Unsafe status check context: ${context}`);
-  }
-  return normalized;
-}
-
-function normalizeContexts(contexts = []) {
-  return [...new Set((Array.isArray(contexts) ? contexts : []).map((value) => {
-    const normalized = String(value || '').trim();
-    return normalized ? assertSafeStatusContext(normalized) : '';
-  }).filter(Boolean))].sort((left, right) => left.localeCompare(right));
-}
-
-function loadBranchProtectionRule(repo, runner = runGh) {
-  const { owner, name } = splitRepo(repo);
-  const query = `
-    query BranchProtectionRules($owner: String!, $name: String!) {
-      repository(owner: $owner, name: $name) {
-        branchProtectionRules(first: 50) {
-          nodes {
-            id
-            pattern
-            requiresStatusChecks
-            requiredStatusCheckContexts
-            requiresApprovingReviews
-            requiresConversationResolution
-          }
-        }
-      }
-    }
-  `;
-
-  const result = runner([
-    'api',
-    'graphql',
-    '-f',
-    `query=${query}`,
-    '-f',
-    `owner=${owner}`,
-    '-f',
-    `name=${name}`,
-  ]);
-
-  if (result.status !== 0) {
-    throw new Error(`Failed to load branch protection: ${formatGhError(result)}`);
-  }
-
-  const payload = JSON.parse(result.stdout || '{}');
-  return payload.data?.repository?.branchProtectionRules?.nodes || [];
-}
-
-function findBranchProtectionRule(rules, branch) {
-  return (Array.isArray(rules) ? rules : []).find((rule) => rule.pattern === branch) || null;
-}
-
-function diffContexts(actual, expected) {
-  const actualSet = new Set(normalizeContexts(actual));
-  const expectedSet = new Set(normalizeContexts(expected));
-
-  return {
-    missing: [...expectedSet].filter((value) => !actualSet.has(value)),
-    unexpected: [...actualSet].filter((value) => !expectedSet.has(value)),
-  };
-}
-
-function updateBranchProtectionRule(ruleId, requiredStatusCheckContexts, runner = runGh) {
-  const safeRuleId = assertSafeRuleId(ruleId);
-  const contexts = normalizeContexts(requiredStatusCheckContexts);
-  const mutation = `
-    mutation UpdateBranchProtectionRule($ruleId: ID!, $contexts: [String!]) {
-      updateBranchProtectionRule(input: {
-        branchProtectionRuleId: $ruleId
-        requiresStatusChecks: true
-        requiredStatusCheckContexts: $contexts
-      }) {
-        branchProtectionRule {
-          id
-          pattern
-          requiresStatusChecks
-          requiredStatusCheckContexts
-        }
-      }
-    }
-  `;
-
-  const args = [
-    'api',
-    'graphql',
-    '-f',
-    `query=${mutation}`,
-    '-f',
-    `ruleId=${safeRuleId}`,
-  ];
-  for (const context of contexts) {
-    args.push('-F', `contexts[]=${context}`);
-  }
-
-  const result = runner(args);
-
-  if (result.status !== 0) {
-    throw new Error(`Failed to update branch protection: ${formatGhError(result)}`);
-  }
-
-  return JSON.parse(result.stdout || '{}').data?.updateBranchProtectionRule?.branchProtectionRule || null;
-}
-
-function syncBranchProtection(options = {}, runner = runGh) {
-  const repo = options.repo || DEFAULT_REPO;
-  const branch = assertSafeBranchPattern(options.branch || DEFAULT_BRANCH);
-  const expectedContexts = normalizeContexts(MERGE_QUALITY_CHECKS.requiredStatusCheckContexts);
-  const rules = loadBranchProtectionRule(repo, runner);
-  const rule = findBranchProtectionRule(rules, branch);
-
-  if (!rule) {
-    throw new Error(`No branch protection rule found for ${repo}#${branch}.`);
-  }
-
-  const actualContexts = normalizeContexts(rule.requiredStatusCheckContexts);
-  const diff = diffContexts(actualContexts, expectedContexts);
-  const inSync = diff.missing.length === 0 && diff.unexpected.length === 0 && rule.requiresStatusChecks === true;
-
-  if (options.check) {
-    return {
-      ok: inSync,
-      repo,
-      branch,
-      ruleId: rule.id,
-      actualContexts,
-      expectedContexts,
-      diff,
-    };
-  }
-
-  const updatedRule = inSync
-    ? rule
-    : updateBranchProtectionRule(rule.id, expectedContexts, runner);
-  const finalContexts = normalizeContexts(updatedRule.requiredStatusCheckContexts);
-  const finalDiff = diffContexts(finalContexts, expectedContexts);
-
-  return {
-    ok: true,
-    repo,
-    branch,
-    ruleId: rule.id,
-    actualContexts: finalContexts,
-    expectedContexts,
-    diff: finalDiff,
-    updated: !inSync,
-  };
-}
-
-function runCli(argv = process.argv.slice(2), runner = runGh) {
-  const options = parseArgs(argv);
-  const result = syncBranchProtection(options, runner);
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (options.check) {
-    const status = result.ok ? 'ok' : 'drift';
-    console.log(`Branch protection ${status}: ${result.repo} ${result.branch}`);
-    if (!result.ok) {
-      if (result.diff.missing.length > 0) {
-        console.log(`Missing contexts: ${result.diff.missing.join(', ')}`);
-      }
-      if (result.diff.unexpected.length > 0) {
-        console.log(`Unexpected contexts: ${result.diff.unexpected.join(', ')}`);
-      }
-    }
-  } else {
-    console.log(`Branch protection synced: ${result.repo} ${result.branch}`);
-  }
-
-  return options.check ? (result.ok ? 0 : 1) : 0;
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === __filename) {
-  process.exitCode = runCli();
-}
-
-module.exports = {
-  assertSafeBranchPattern,
-  assertSafeGhArgs,
-  assertSafeRuleId,
-  assertSafeStatusContext,
-  diffContexts,
-  findBranchProtectionRule,
-  loadBranchProtectionRule,
-  normalizeContexts,
-  parseArgs,
-  resolveGhBinary,
-  runCli,
-  splitRepo,
-  syncBranchProtection,
-  updateBranchProtectionRule,
-};