thumbgate 0.9.10 → 0.9.11

package/scripts/mcp-config.js

@@ -3,6 +3,9 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { publishedCliArgs, runPublishedCliHelp } = require('./published-cli');
+const DEFAULT_PKG_ROOT = path.join(__dirname, '..');
+const cliAvailabilityCache = new Map();
 
 function isSourceCheckout(pkgRoot) {
   return fs.existsSync(path.join(pkgRoot, '.git'));
@@ -17,17 +20,40 @@ function parseWorktreePaths(raw) {
 }
 
 function resolveStableSourceRoot(pkgRoot) {
-  if (!isSourceCheckout(pkgRoot)) {
+  const effectivePkgRoot =
+    typeof pkgRoot === 'string' && pkgRoot.trim() ? pkgRoot : DEFAULT_PKG_ROOT;
+
+  if (!isSourceCheckout(effectivePkgRoot)) {
     return null;
   }
 
+  let preferredBasenames = [];
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(effectivePkgRoot, 'package.json'), 'utf8'));
+    const packageName = String(pkg && pkg.name || '').trim().toLowerCase();
+    if (packageName) {
+      preferredBasenames.push(packageName);
+      preferredBasenames.push(packageName.replace(/[^a-z0-9]+/g, ''));
+    }
+  } catch (_) {
+    preferredBasenames = [];
+  }
+
   try {
-    const output = execFileSync('git', ['-C', pkgRoot, 'worktree', 'list', '--porcelain'], {
+    const output = execFileSync('git', ['-C', effectivePkgRoot, 'worktree', 'list', '--porcelain'], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
     });
     const worktreePaths = parseWorktreePaths(output);
 
+    for (const worktreePath of worktreePaths) {
+      const baseName = path.basename(worktreePath).toLowerCase();
+      const normalizedBaseName = baseName.replace(/[^a-z0-9]+/g, '');
+      if (preferredBasenames.includes(baseName) || preferredBasenames.includes(normalizedBaseName)) {
+        return worktreePath;
+      }
+    }
+
     for (const worktreePath of worktreePaths) {
       const gitPath = path.join(worktreePath, '.git');
       if (!fs.existsSync(gitPath)) {
@@ -38,10 +64,10 @@ function resolveStableSourceRoot(pkgRoot) {
       }
     }
   } catch (_) {
-    return pkgRoot;
+    return effectivePkgRoot;
   }
 
-  return pkgRoot;
+  return effectivePkgRoot;
 }
 
 function resolveGitCommonDir(dirPath) {
@@ -76,7 +102,7 @@ function resolveLocalServerPath(pkgRoot, scope = 'project') {
 function portableMcpEntry(pkgVersion) {
   return {
     command: 'npx',
-    args: ['-y', `thumbgate@${pkgVersion}`, 'serve'],
+    args: publishedCliArgs(pkgVersion, ['serve']),
   };
 }
 
@@ -125,17 +151,53 @@ function isVersionPublished(pkgVersion) {
   return published;
 }
 
+function publishedCliOverride() {
+  const override = String(process.env.THUMBGATE_PUBLISHED_CLI_STATE || '').trim().toLowerCase();
+  if (override === 'available') {
+    return true;
+  }
+  if (override === 'unavailable') {
+    return false;
+  }
+  return null;
+}
+
+function publishedCliAvailable(pkgVersion) {
+  if (!isVersionPublished(pkgVersion)) {
+    return false;
+  }
+  const override = publishedCliOverride();
+  if (override !== null) {
+    return override;
+  }
+  if (cliAvailabilityCache.has(pkgVersion)) {
+    return cliAvailabilityCache.get(pkgVersion);
+  }
+
+  let available = false;
+  try {
+    runPublishedCliHelp(pkgVersion, { timeout: 8000 });
+    available = true;
+  } catch (_) {
+    available = false;
+  }
+
+  cliAvailabilityCache.set(pkgVersion, available);
+  return available;
+}
+
 function resolveMcpEntry({ pkgRoot, pkgVersion, scope = 'project', targetDir = pkgRoot }) {
   if (!isSourceCheckout(pkgRoot)) {
     return portableMcpEntry(pkgVersion);
   }
-  if (scope === 'project' && !isSameCheckoutFamily(pkgRoot, targetDir) && isVersionPublished(pkgVersion)) {
+  if (scope === 'project' && !isSameCheckoutFamily(pkgRoot, targetDir) && publishedCliAvailable(pkgVersion)) {
     return portableMcpEntry(pkgVersion);
   }
   return localMcpEntry(pkgRoot, scope);
 }
 
 module.exports = {
+  publishedCliAvailable,
   isVersionPublished,
   isSourceCheckout,
   isSameCheckoutFamily,

package/scripts/meta-policy.js

@@ -17,10 +17,10 @@
 
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const { parseTimestamp } = require('./feedback-schema');
 const { timeDecayWeight } = require('./thompson-sampling');
 const { inferDomain } = require('./feedback-loop');
+const { resolveFeedbackDir } = require('./feedback-paths');
 
 const MIN_OCCURRENCES = 2;
 const RECENT_DAYS = 7;
@@ -30,13 +30,11 @@ const RECENT_MS = RECENT_DAYS * 24 * 3600 * 1000;
  * Extract meta-policy rules from memory-log.jsonl feedback trends.
  *
  * @param {object} opts
- * @param {string} [opts.feedbackDir] - Override feedback directory (default: THUMBGATE_FEEDBACK_DIR or ~/.claude/memory/feedback)
+ * @param {string} [opts.feedbackDir] - Override feedback directory (default: active ThumbGate feedback dir)
  * @returns {Array<{category: string, confidence: number, trend: string, occurrence_count: number, last_seen: string}>}
  */
 function extractMetaPolicyRules(opts = {}) {
-  const feedbackDir = opts.feedbackDir
-    || process.env.THUMBGATE_FEEDBACK_DIR
-    || path.join(os.homedir(), '.claude', 'memory', 'feedback');
+  const feedbackDir = opts.feedbackDir || resolveFeedbackDir();
 
   const memoryLogPath = path.join(feedbackDir, 'memory-log.jsonl');
 
@@ -160,9 +158,7 @@ function extractMetaPolicyRules(opts = {}) {
  * @returns {{ rules: Array, outputPath: string }}
  */
 function run(opts = {}) {
-  const feedbackDir = opts.feedbackDir
-    || process.env.THUMBGATE_FEEDBACK_DIR
-    || path.join(os.homedir(), '.claude', 'memory', 'feedback');
+  const feedbackDir = opts.feedbackDir || resolveFeedbackDir();
 
   const rules = extractMetaPolicyRules({ ...opts, feedbackDir });
 

package/scripts/money-watcher.js

@@ -6,10 +6,19 @@
 
 'use strict';
 
+const fs = require('node:fs');
+const path = require('node:path');
 const { getOperationalBillingSummary } = require('./operational-summary');
 
-function getCommercialRevenueSnapshot(summary) {
-  const revenue = summary.revenue || {};
+const DEFAULT_STATE_PATH = path.resolve(__dirname, '..', '.thumbgate', 'commercial-watch-state.json');
+const DEFAULT_ALERT_LOG_PATH = path.resolve(__dirname, '..', '.thumbgate', 'commercial-alerts.jsonl');
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function getCommercialRevenueSnapshot(summary = {}) {
+  const revenue = summary && typeof summary === 'object' ? summary.revenue || {} : {};
   return {
     paidOrders: revenue.paidOrders || 0,
     bookedRevenueCents: revenue.bookedRevenueCents || 0,
@@ -18,10 +27,86 @@ function getCommercialRevenueSnapshot(summary) {
   };
 }
 
-async function watchMoney(intervalMs = 10000) {
+function readSnapshotState(statePath = DEFAULT_STATE_PATH) {
+  try {
+    if (!fs.existsSync(statePath)) {
+      return null;
+    }
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeSnapshotState(snapshot, statePath = DEFAULT_STATE_PATH) {
+  ensureParentDir(statePath);
+  fs.writeFileSync(statePath, `${JSON.stringify(snapshot, null, 2)}\n`, 'utf8');
+  return statePath;
+}
+
+function buildCommercialAlert(previousSnapshot = {}, currentSnapshot = {}, meta = {}) {
+  const newPaidOrders = (currentSnapshot.paidOrders || 0) - (previousSnapshot.paidOrders || 0);
+  const newBookedRevenueCents = (currentSnapshot.bookedRevenueCents || 0) - (previousSnapshot.bookedRevenueCents || 0);
+
+  if (newPaidOrders <= 0 && newBookedRevenueCents <= 0) {
+    return null;
+  }
+
+  return {
+    detectedAt: new Date().toISOString(),
+    source: meta.source || null,
+    fallbackReason: meta.fallbackReason || null,
+    newPaidOrders,
+    newBookedRevenueCents,
+    latestPaidAt: currentSnapshot.latestPaidAt || null,
+    latestPaidOrder: currentSnapshot.latestPaidOrder || null,
+    paidOrders: currentSnapshot.paidOrders || 0,
+    bookedRevenueCents: currentSnapshot.bookedRevenueCents || 0,
+  };
+}
+
+function recordCommercialAlert(alert, alertLogPath = DEFAULT_ALERT_LOG_PATH) {
+  ensureParentDir(alertLogPath);
+  fs.appendFileSync(alertLogPath, `${JSON.stringify(alert)}\n`, 'utf8');
+  return alertLogPath;
+}
+
+async function checkForCommercialChange(options = {}) {
+  const statePath = options.statePath || DEFAULT_STATE_PATH;
+  const alertLogPath = options.alertLogPath || DEFAULT_ALERT_LOG_PATH;
+  const previousSnapshot = options.previousSnapshot || readSnapshotState(statePath) || getCommercialRevenueSnapshot();
+  const summaryResolver = options.getSummary || getOperationalBillingSummary;
+  const { source, summary, fallbackReason } = await summaryResolver();
+  const currentSnapshot = getCommercialRevenueSnapshot(summary);
+  const alert = buildCommercialAlert(previousSnapshot, currentSnapshot, {
+    source,
+    fallbackReason,
+  });
+
+  writeSnapshotState(currentSnapshot, statePath);
+  if (alert) {
+    recordCommercialAlert(alert, alertLogPath);
+  }
+
+  return {
+    changed: Boolean(alert),
+    alert,
+    previousSnapshot,
+    currentSnapshot,
+    source,
+    fallbackReason: fallbackReason || null,
+    statePath,
+    alertLogPath,
+  };
+}
+
+async function watchMoney(intervalMs = 10000, options = {}) {
   console.log('👀 Money Watcher activated. Polling billing summary for commercial changes...');
   const initialState = await getOperationalBillingSummary();
-  let initialSnapshot = getCommercialRevenueSnapshot(initialState.summary);
+  let initialSnapshot = options.initialSnapshot
+    || readSnapshotState(options.statePath || DEFAULT_STATE_PATH)
+    || getCommercialRevenueSnapshot(initialState.summary);
+  writeSnapshotState(initialSnapshot, options.statePath || DEFAULT_STATE_PATH);
   let polling = false;
 
   return setInterval(async () => {
@@ -30,21 +115,18 @@ async function watchMoney(intervalMs = 10000) {
     try {
       const { source, summary, fallbackReason } = await getOperationalBillingSummary();
       const currentSnapshot = getCommercialRevenueSnapshot(summary);
+      const alert = buildCommercialAlert(initialSnapshot, currentSnapshot, {
+        source,
+        fallbackReason,
+      });
+      writeSnapshotState(currentSnapshot, options.statePath || DEFAULT_STATE_PATH);
 
-      const newPaidOrders = currentSnapshot.paidOrders - initialSnapshot.paidOrders;
-      const newBookedRevenue = currentSnapshot.bookedRevenueCents - initialSnapshot.bookedRevenueCents;
-
-      if (newPaidOrders > 0 || newBookedRevenue > 0) {
+      if (alert) {
+        recordCommercialAlert(alert, options.alertLogPath || DEFAULT_ALERT_LOG_PATH);
         console.log('\n🚨🚨🚨 COMMERCIAL ALERT: NET-NEW PAID ACTIVITY DETECTED! 🚨🚨🚨');
         console.log('Operational billing summary:');
         console.log(JSON.stringify({
-          source,
-          fallbackReason,
-          newPaidOrders,
-          newBookedRevenueCents: newBookedRevenue,
-          latestPaidAt: currentSnapshot.latestPaidAt,
-          latestPaidOrder: currentSnapshot.latestPaidOrder,
-          bookedRevenueCents: currentSnapshot.bookedRevenueCents,
+          ...alert,
           activeKeys: summary.keys.active,
           totalUsage: summary.keys.totalUsage,
         }, null, 2));
@@ -58,14 +140,82 @@ async function watchMoney(intervalMs = 10000) {
   }, intervalMs);
 }
 
+function parseArgs(argv = []) {
+  const options = {
+    once: false,
+    intervalMs: 10000,
+    statePath: DEFAULT_STATE_PATH,
+    alertLogPath: DEFAULT_ALERT_LOG_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = String(argv[index] || '').trim();
+
+    if (arg === '--once') {
+      options.once = true;
+      continue;
+    }
+
+    if (arg === '--interval-ms' && argv[index + 1]) {
+      options.intervalMs = Number.parseInt(argv[index + 1], 10) || options.intervalMs;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--interval-ms=')) {
+      options.intervalMs = Number.parseInt(arg.split('=').slice(1).join('='), 10) || options.intervalMs;
+      continue;
+    }
+
+    if (arg === '--state-path' && argv[index + 1]) {
+      options.statePath = path.resolve(String(argv[index + 1]));
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--state-path=')) {
+      options.statePath = path.resolve(arg.split('=').slice(1).join('='));
+      continue;
+    }
+
+    if (arg === '--alert-log-path' && argv[index + 1]) {
+      options.alertLogPath = path.resolve(String(argv[index + 1]));
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--alert-log-path=')) {
+      options.alertLogPath = path.resolve(arg.split('=').slice(1).join('='));
+    }
+  }
+
+  return options;
+}
+
 if (require.main === module) {
-  watchMoney().catch((err) => {
+  const options = parseArgs(process.argv.slice(2));
+  const runner = options.once
+    ? checkForCommercialChange(options).then((result) => {
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    })
+    : watchMoney(options.intervalMs, options);
+
+  runner.catch((err) => {
     console.error(err && err.message ? err.message : err);
     process.exit(1);
   });
 }
 
 module.exports = {
+  DEFAULT_ALERT_LOG_PATH,
+  DEFAULT_STATE_PATH,
+  buildCommercialAlert,
+  checkForCommercialChange,
   getCommercialRevenueSnapshot,
+  parseArgs,
+  readSnapshotState,
+  recordCommercialAlert,
   watchMoney,
+  writeSnapshotState,
 };

package/scripts/obsidian-export.js

@@ -346,6 +346,7 @@ function exportGates(configPath, outputDir) {
   // Read auto-promoted gates if present (check common locations)
   const autoGatePaths = [
     path.join(path.dirname(configPath), '..', '.thumbgate', 'auto-promoted-gates.json'),
+    path.join(path.dirname(configPath), '..', '.rlhf', 'auto-promoted-gates.json'),
     path.join(path.dirname(configPath), '..', '.claude', 'memory', 'feedback', 'auto-promoted-gates.json'),
   ];
   for (const agPath of autoGatePaths) {