thumbgate 0.9.9 → 0.9.11

package/src/api/server.js

@@ -90,7 +90,15 @@ const {
   loadStats: loadGateStats,
   setConstraint,
   loadConstraints,
+  setTaskScope,
+  setBranchGovernance,
+  getScopeState,
+  getBranchGovernanceState,
+  approveProtectedAction,
 } = require('../../scripts/gates-engine');
+const {
+  evaluateOperationalIntegrity,
+} = require('../../scripts/operational-integrity');
 const {
   generateDashboard,
 } = require('../../scripts/dashboard');
@@ -109,7 +117,7 @@ const {
   readJSONLLocal,
 } = require('../../scripts/lesson-synthesis');
 const {
-  searchRlhf,
+  searchThumbgate,
 } = require('../../scripts/thumbgate-search');
 const {
   appendTelemetryPing,
@@ -141,11 +149,13 @@ const {
 } = require('../../scripts/seo-gsd');
 
 const LANDING_PAGE_PATH = path.resolve(__dirname, '../../public/index.html');
+const PRO_PAGE_PATH = path.resolve(__dirname, '../../public/pro.html');
 const DASHBOARD_PAGE_PATH = path.resolve(__dirname, '../../public/dashboard.html');
 const LESSONS_PAGE_PATH = path.resolve(__dirname, '../../public/lessons.html');
 const GUIDE_PAGE_PATH = path.resolve(__dirname, '../../public/guide.html');
 const LEARN_PAGE_PATH = path.resolve(__dirname, '../../public/learn.html');
 const LEARN_DIR = path.resolve(__dirname, '../../public/learn');
+const BUYER_INTENT_SCRIPT_PATH = path.resolve(__dirname, '../../public/js/buyer-intent.js');
 const VISITOR_COOKIE_NAME = 'thumbgate_visitor_id';
 const SESSION_COOKIE_NAME = 'thumbgate_session_id';
 const ACQUISITION_COOKIE_NAME = 'thumbgate_acquisition_id';
@@ -215,6 +225,29 @@ function findRecordById(id, feedbackDir) {
   return { feedbackEvent, memoryRecord };
 }
 
+function mergeFollowUpDetail(existingDetail, followUpText) {
+  const existing = normalizeNullableText(existingDetail);
+  const next = normalizeNullableText(followUpText);
+  if (!next) return existing;
+  if (!existing) return next;
+  if (existing.includes(next)) return existing;
+  return `${existing}\n\nFollow-up: ${next}`;
+}
+
+function updateLessonRecord(feedbackDir, lessonId, updater) {
+  const record = findRecordById(lessonId, feedbackDir);
+  if (!record) return null;
+  const existing = { ...(record.feedbackEvent || {}), ...(record.memoryRecord || {}) };
+  const updated = updater({ ...existing });
+  if (!updated) return null;
+  const memoryLogPath = path.join(feedbackDir, 'memory-log.jsonl');
+  const feedbackLogPath = path.join(feedbackDir, 'feedback-log.jsonl');
+  const updatedMemory = updateRecordInJsonl(memoryLogPath, lessonId, updated);
+  const updatedFeedback = updateRecordInJsonl(feedbackLogPath, lessonId, updated);
+  if (!updatedMemory && !updatedFeedback) return null;
+  return updated;
+}
+
 function getPublicMcpTools() {
   return MCP_TOOLS.map((tool) => ({
     name: tool.name,
@@ -862,8 +895,8 @@ function escapeHtmlAttribute(value) {
     .replaceAll('>', '>');
 }
 
-function loadLandingPageHtml(runtimeConfig, pageContext = {}) {
-  const template = fs.readFileSync(LANDING_PAGE_PATH, 'utf-8');
+function loadPublicMarketingTemplateHtml(templatePath, runtimeConfig, pageContext = {}) {
+  const template = fs.readFileSync(templatePath, 'utf-8');
   const googleSiteVerificationMeta = runtimeConfig.googleSiteVerification
     ? `  <meta name="google-site-verification" content="${escapeHtmlAttribute(runtimeConfig.googleSiteVerification)}" />`
     : '';
@@ -900,6 +933,14 @@ function loadLandingPageHtml(runtimeConfig, pageContext = {}) {
   });
 }
 
+function loadLandingPageHtml(runtimeConfig, pageContext = {}) {
+  return loadPublicMarketingTemplateHtml(LANDING_PAGE_PATH, runtimeConfig, pageContext);
+}
+
+function loadProPageHtml(runtimeConfig, pageContext = {}) {
+  return loadPublicMarketingTemplateHtml(PRO_PAGE_PATH, runtimeConfig, pageContext);
+}
+
 function loadDashboardPageHtml(req, expectedApiKey) {
   const template = fs.readFileSync(DASHBOARD_PAGE_PATH, 'utf-8');
   const forwardedHost = req.headers['x-forwarded-host'];
@@ -937,6 +978,13 @@ function loadLessonsPageHtml(req, expectedApiKey) {
 
 function esc(s) { return String(s || '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;'); }
 
+function normalizeLessonSignal(signal) {
+  const value = String(signal || '').toLowerCase();
+  if (value === 'up' || value === 'positive' || value === 'thumbs_up') return 'up';
+  if (value === 'down' || value === 'negative' || value === 'thumbs_down') return 'down';
+  return 'down';
+}
+
 function renderLessonDetailHtml(record, lessonId) {
   if (!record) {
     return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Lesson Not Found</title>
@@ -952,7 +1000,7 @@ a{color:#22d3ee;text-decoration:none}</style></head><body>
   const fb = record.feedbackEvent || {};
   const mem = record.memoryRecord || {};
   const merged = { ...fb, ...mem };
-  const signal = merged.signal || 'down';
+  const signal = normalizeLessonSignal(merged.signal);
   const emoji = signal === 'up' ? '👍' : '👎';
   const signalColor = signal === 'up' ? '#4ade80' : '#f87171';
   const title = merged.title || merged.context || 'Untitled Lesson';
@@ -1228,6 +1276,7 @@ function renderRobotsTxt(runtimeConfig) {
 function renderSitemapXml(runtimeConfig) {
   const entries = [
     { path: '/', changefreq: 'weekly', priority: '1.0' },
+    { path: '/pro', changefreq: 'weekly', priority: '0.9' },
     ...THUMBGATE_SEO_SITEMAP_ENTRIES,
   ];
   return [
@@ -1550,7 +1599,7 @@ function renderCheckoutSuccessPage(runtimeConfig) {
     }
 
     function sendTelemetryOnce(eventType, extra = {}) {
-      const marker = ['rlhf', eventType, sessionId || traceId || 'unknown'].join(':');
+      const marker = ['thumbgate', eventType, sessionId || traceId || 'unknown'].join(':');
       try {
         if (window.sessionStorage && window.sessionStorage.getItem(marker)) {
           return;
@@ -2157,6 +2206,24 @@ function createApiServer() {
       return;
     }
 
+    if (isGetLikeRequest && pathname === '/js/buyer-intent.js') {
+      try {
+        const script = fs.readFileSync(BUYER_INTENT_SCRIPT_PATH, 'utf-8');
+        res.writeHead(200, {
+          'Content-Type': 'application/javascript; charset=utf-8',
+          'Cache-Control': 'public, max-age=86400',
+        });
+        if (!isHeadRequest) {
+          res.end(script);
+        } else {
+          res.end();
+        }
+      } catch {
+        sendJson(res, 404, { error: 'Buyer intent script not found' });
+      }
+      return;
+    }
+
 
     // User feedback → GitHub Issues
     if (req.method === 'POST' && pathname === '/api/feedback/submit') {
@@ -2189,6 +2256,9 @@ function createApiServer() {
       req.on('data', (chunk) => chunks.push(chunk));
       req.on('end', () => {
         try {
+          const accepts = String(req.headers.accept || '').toLowerCase();
+          const requestedWith = String(req.headers['x-requested-with'] || '').toLowerCase();
+          const wantsJson = accepts.includes('application/json') || requestedWith === 'fetch';
           const body = Buffer.concat(chunks).toString();
           const params = new URLSearchParams(body);
           const email = (params.get('email') || '').trim().toLowerCase();
@@ -2199,7 +2269,65 @@ function createApiServer() {
           const newsletterPath = path.join(getFeedbackPaths().FEEDBACK_DIR, 'newsletter-subscribers.jsonl');
           const dir = path.dirname(newsletterPath);
           if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-          fs.appendFileSync(newsletterPath, JSON.stringify({ email, subscribedAt: new Date().toISOString(), source: 'landing-page' }) + '\n');
+          const existingEntries = fs.existsSync(newsletterPath)
+            ? fs.readFileSync(newsletterPath, 'utf8').split('\n').map((line) => line.trim()).filter(Boolean)
+            : [];
+          const duplicate = existingEntries.some((line) => {
+            try {
+              const entry = JSON.parse(line);
+              return String(entry.email || '').trim().toLowerCase() === email;
+            } catch {
+              return false;
+            }
+          });
+          const referrer = String(req.headers.referer || req.headers.referrer || '').trim();
+          let attribution = {};
+          let referrerHost = null;
+          let landingPath = '/';
+          if (referrer) {
+            try {
+              const referrerUrl = new URL(referrer);
+              referrerHost = referrerUrl.host || null;
+              landingPath = referrerUrl.pathname || '/';
+              attribution = {
+                source: referrerUrl.searchParams.get('utm_source') || null,
+                medium: referrerUrl.searchParams.get('utm_medium') || null,
+                campaign: referrerUrl.searchParams.get('utm_campaign') || null,
+                content: referrerUrl.searchParams.get('utm_content') || null,
+                term: referrerUrl.searchParams.get('utm_term') || null,
+                creator: referrerUrl.searchParams.get('creator') || null,
+                community: referrerUrl.searchParams.get('community') || referrerUrl.searchParams.get('subreddit') || null,
+                postId: referrerUrl.searchParams.get('post_id') || referrerUrl.searchParams.get('postId') || null,
+                commentId: referrerUrl.searchParams.get('comment_id') || referrerUrl.searchParams.get('commentId') || null,
+                campaignVariant: referrerUrl.searchParams.get('campaign_variant') || referrerUrl.searchParams.get('variant') || null,
+                offerCode: referrerUrl.searchParams.get('offer_code') || referrerUrl.searchParams.get('offer') || null,
+                landingPath,
+              };
+            } catch {
+              // Ignore invalid referrer values.
+            }
+          }
+          if (!duplicate) {
+            fs.appendFileSync(newsletterPath, JSON.stringify({
+              email,
+              subscribedAt: new Date().toISOString(),
+              source: attribution.source || 'landing-page',
+              referrer: referrer || null,
+              referrerHost,
+              landingPath,
+              attribution,
+            }) + '\n');
+          }
+          if (wantsJson) {
+            sendJson(res, 200, {
+              accepted: true,
+              duplicate,
+              email,
+              landingPath,
+              source: attribution.source || 'landing-page',
+            });
+            return;
+          }
           res.writeHead(302, { Location: '/?subscribed=1' });
           res.end();
         } catch {
@@ -2325,7 +2453,7 @@ async function addContext(){
   const ctx=document.getElementById('contextInput').value.trim();
   if(!ctx)return;
   try{
-    await fetch('/feedback/quick/context',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({signal:'${signal}',context:ctx,relatedFeedbackId:'${feedbackId}'})});
+    await fetch('/feedback/quick/context',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({signal:'${signal}',context:ctx,relatedFeedbackId:'${feedbackId}',feedbackSessionId:'${result.feedbackSession?.sessionId || ''}'})});
     document.getElementById('toast').style.display='block';
     document.getElementById('contextForm').style.display='none';
     setTimeout(()=>document.getElementById('toast').style.display='none',3000);
@@ -2343,6 +2471,7 @@ async function addContext(){
       const signal = body.signal;
       const context = typeof body.context === 'string' ? body.context.trim() : '';
       const relatedFeedbackId = typeof body.relatedFeedbackId === 'string' ? body.relatedFeedbackId.trim() : '';
+      const feedbackSessionId = typeof body.feedbackSessionId === 'string' ? body.feedbackSessionId.trim() : '';
       if (signal !== 'up' && signal !== 'down') {
         sendJson(res, 400, { error: 'signal must be up or down' });
         return;
@@ -2351,18 +2480,45 @@ async function addContext(){
         sendJson(res, 400, { error: 'context is required' });
         return;
       }
-      const result = captureFeedback({
-        signal,
-        context,
+      if (!relatedFeedbackId) {
+        sendJson(res, 400, { error: 'relatedFeedbackId is required' });
+        return;
+      }
+      const feedbackDir = getSafeDataDir();
+      const detailField = signal === 'down' ? 'whatWentWrong' : 'whatWorked';
+      const updated = updateLessonRecord(feedbackDir, relatedFeedbackId, (existing) => {
+        const nextTags = Array.from(new Set([
+          ...((Array.isArray(existing.tags) ? existing.tags : []).filter(Boolean)),
+          'statusline',
+          'quick-capture',
+          'follow-up-context',
+        ]));
+        return {
+          ...existing,
+          tags: nextTags,
+          [detailField]: mergeFollowUpDetail(existing[detailField], context),
+        };
+      });
+      if (!updated) {
+        sendJson(res, 404, { error: 'Related lesson not found' });
+        return;
+      }
+      let feedbackSession = null;
+      if (feedbackSessionId) {
+        try {
+          const { appendToSession } = require('../../scripts/feedback-session');
+          feedbackSession = appendToSession(feedbackSessionId, context, 'user');
+        } catch (_err) {
+          feedbackSession = { status: 'error' };
+        }
+      }
+      sendJson(res, 200, {
+        ok: true,
         relatedFeedbackId,
-        chatHistory: readRecentConversationWindow({
-          feedbackDir: getSafeDataDir(),
-          limit: 10,
-        }),
-        tags: ['statusline', 'quick-capture', 'follow-up-context'],
+        detailField,
+        updated,
+        feedbackSession,
       });
-      const code = result.accepted ? 200 : 422;
-      sendJson(res, code, result);
       return;
     }
 
@@ -2382,28 +2538,27 @@ async function addContext(){
       const lessonId = decodeURIComponent(lessonUpdateMatch[1]);
       const feedbackDir = getSafeDataDir();
       const body = await parseJsonBody(req);
-      const memoryLogPath = path.join(feedbackDir, 'memory-log.jsonl');
       const record = findRecordById(lessonId, feedbackDir);
       if (!record) {
         sendJson(res, 404, { error: 'Record not found' });
         return;
       }
-      const existing = record.memoryRecord || record.feedbackEvent || {};
-      const updated = { ...existing };
-      if (body.title !== undefined) updated.title = body.title;
-      if (body.content !== undefined) updated.context = body.content;
-      if (body.tags !== undefined) {
-        updated.tags = typeof body.tags === 'string'
-          ? body.tags.split(',').map((t) => t.trim()).filter(Boolean)
-          : body.tags;
-      }
-      if (body.whatWentWrong !== undefined) updated.whatWentWrong = body.whatWentWrong;
-      if (body.whatWorked !== undefined) updated.whatWorked = body.whatWorked;
-      const success = updateRecordInJsonl(memoryLogPath, lessonId, updated);
-      if (!success) {
-        // Try feedback log
-        const feedbackLogPath = path.join(feedbackDir, 'feedback-log.jsonl');
-        updateRecordInJsonl(feedbackLogPath, lessonId, updated);
+      const updated = updateLessonRecord(feedbackDir, lessonId, (existing) => {
+        const next = { ...existing };
+        if (body.title !== undefined) next.title = body.title;
+        if (body.content !== undefined) next.context = body.content;
+        if (body.tags !== undefined) {
+          next.tags = typeof body.tags === 'string'
+            ? body.tags.split(',').map((t) => t.trim()).filter(Boolean)
+            : body.tags;
+        }
+        if (body.whatWentWrong !== undefined) next.whatWentWrong = body.whatWentWrong;
+        if (body.whatWorked !== undefined) next.whatWorked = body.whatWorked;
+        return next;
+      });
+      if (!updated) {
+        sendJson(res, 404, { error: 'Record not found' });
+        return;
       }
       sendJson(res, 200, { ok: true, updated });
       return;
@@ -2472,6 +2627,25 @@ async function addContext(){
       return;
     }
 
+    if (isGetLikeRequest && pathname === '/pro') {
+      try {
+        servePublicMarketingPage({
+          req,
+          res,
+          parsed,
+          hostedConfig,
+          isHeadRequest,
+          renderHtml: loadProPageHtml,
+          extraTelemetry: {
+            pageType: 'pro_landing',
+          },
+        });
+      } catch (err) {
+        sendText(res, 500, err.message || 'Pro page unavailable');
+      }
+      return;
+    }
+
     if (isGetLikeRequest && pathname === '/guide') {
       try {
         const html = fs.readFileSync(GUIDE_PAGE_PATH, 'utf-8');
@@ -2539,7 +2713,7 @@ async function addContext(){
           version: pkg.version,
           status: 'ok',
           docs: 'https://github.com/IgorGanapolsky/ThumbGate',
-          endpoints: ['/health', '/dashboard', '/guide', '/learn', '/v1/feedback/capture', '/v1/feedback/stats', '/v1/feedback/summary', '/v1/lessons/search', '/v1/search', '/v1/dashboard', '/v1/dashboard/render-spec', '/v1/settings/status', '/v1/dpo/export', '/v1/analytics/databricks/export'],
+          endpoints: ['/health', '/dashboard', '/guide', '/learn', '/pro', '/v1/feedback/capture', '/v1/feedback/stats', '/v1/feedback/summary', '/v1/lessons/search', '/v1/search', '/v1/dashboard', '/v1/dashboard/render-spec', '/v1/settings/status', '/v1/dpo/export', '/v1/analytics/databricks/export'],
         }, {}, {
           headOnly: isHeadRequest,
         });
@@ -3490,6 +3664,80 @@ async function addContext(){
         return;
       }
 
+      if (req.method === 'POST' && pathname === '/v1/gates/task-scope') {
+        const body = await parseJsonBody(req);
+        const scope = setTaskScope({
+          taskId: body.taskId,
+          summary: body.summary,
+          allowedPaths: body.allowedPaths,
+          protectedPaths: body.protectedPaths,
+          repoPath: body.repoPath,
+          localOnly: body.localOnly === true,
+          clear: body.clear === true,
+        });
+        sendJson(res, 200, { scope });
+        return;
+      }
+
+      if (req.method === 'GET' && pathname === '/v1/gates/task-scope') {
+        sendJson(res, 200, getScopeState());
+        return;
+      }
+
+      if (req.method === 'POST' && pathname === '/v1/gates/branch-governance') {
+        const body = await parseJsonBody(req);
+        const branchGovernance = setBranchGovernance({
+          branchName: body.branchName,
+          baseBranch: body.baseBranch,
+          prRequired: body.prRequired,
+          prNumber: body.prNumber,
+          prUrl: body.prUrl,
+          queueRequired: body.queueRequired,
+          localOnly: body.localOnly === true,
+          releaseVersion: body.releaseVersion,
+          releaseEvidence: body.releaseEvidence,
+          releaseSensitiveGlobs: body.releaseSensitiveGlobs,
+          clear: body.clear === true,
+        });
+        sendJson(res, 200, { branchGovernance });
+        return;
+      }
+
+      if (req.method === 'GET' && pathname === '/v1/gates/branch-governance') {
+        sendJson(res, 200, { branchGovernance: getBranchGovernanceState() });
+        return;
+      }
+
+      if (req.method === 'POST' && pathname === '/v1/gates/protected-approval') {
+        const body = await parseJsonBody(req);
+        const approval = approveProtectedAction({
+          pathGlobs: body.pathGlobs,
+          reason: body.reason,
+          evidence: body.evidence,
+          taskId: body.taskId,
+          ttlMs: body.ttlMs,
+        });
+        sendJson(res, 200, { approved: true, approval });
+        return;
+      }
+
+      if (req.method === 'GET' && pathname === '/v1/ops/integrity') {
+        const command = parsed.searchParams.get('command') || undefined;
+        const baseBranch = parsed.searchParams.get('baseBranch') || undefined;
+        const requirePrForReleaseSensitive = parsed.searchParams.get('requirePrForReleaseSensitive') === 'true';
+        const requireVersionNotBehindBase = parsed.searchParams.get('requireVersionNotBehindBase') === 'true';
+        const report = evaluateOperationalIntegrity({
+          repoPath: process.cwd(),
+          baseBranch,
+          command,
+          requirePrForReleaseSensitive,
+          requireVersionNotBehindBase,
+          branchGovernance: getBranchGovernanceState(),
+        });
+        sendJson(res, 200, report);
+        return;
+      }
+
       if (req.method === 'GET' && pathname === '/v1/feedback/summary') {
         const recent = Number(parsed.searchParams.get('recent') || 20);
         const summary = feedbackSummary(Number.isFinite(recent) ? recent : 20);
@@ -3521,7 +3769,7 @@ async function addContext(){
         const signal = parsed.searchParams.get('signal') || null;
         let results;
         try {
-          results = searchRlhf({
+          results = searchThumbgate({
             query,
             limit: Number.isFinite(limit) ? limit : 10,
             source,
@@ -3538,7 +3786,7 @@ async function addContext(){
         const body = await parseJsonBody(req);
         let results;
         try {
-          results = searchRlhf({
+          results = searchThumbgate({
             query: body.query || body.q || '',
             limit: body.limit,
             source: body.source,
@@ -4173,17 +4421,19 @@ async function addContext(){
   });
 }
 
-function startServer({ port } = {}) {
+function startServer({ port, host } = {}) {
   const listenPort = Number(port ?? process.env.PORT ?? 8787);
+  const listenHost = String(host ?? process.env.HOST ?? '0.0.0.0').trim() || '0.0.0.0';
   const server = createApiServer();
   return new Promise((resolve) => {
-    server.listen(listenPort, () => {
+    server.listen(listenPort, listenHost, () => {
       const address = server.address();
       const actualPort = (address && typeof address === 'object' && address.port)
         ? address.port
         : listenPort;
       resolve({
         server,
+        host: listenHost,
         port: actualPort,
       });
     });
@@ -4200,7 +4450,7 @@ module.exports = {
 };
 
 if (require.main === module) {
-  startServer().then(({ port }) => {
-    console.log(`ThumbGate API listening on http://localhost:${port}`);
+  startServer().then(({ host, port }) => {
+    console.log(`ThumbGate API listening on http://${host}:${port}`);
   });
 }