thumbgate 0.9.10

package/scripts/prove-seo-gsd.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+
+function resolveProofPaths() {
+  const proofDir = process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
+  return {
+    proofDir,
+    reportJson: path.join(proofDir, 'seo-gsd-report.json'),
+    reportMd: path.join(proofDir, 'seo-gsd-report.md'),
+  };
+}
+
+async function run() {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-seo-gsd-proof-'));
+  const results = { passed: 0, failed: 0, requirements: {} };
+  const { proofDir, reportJson, reportMd } = resolveProofPaths();
+
+  const checks = [
+    {
+      id: 'SEO-GSD-01',
+      desc: 'buildThumbGateSeoPlan returns GSD stages and four high-ROI public pages',
+      fn: () => {
+        delete require.cache[require.resolve('./seo-gsd')];
+        const { buildThumbGateSeoPlan, HIGH_ROI_QUERY_SEEDS } = require('./seo-gsd');
+        const plan = buildThumbGateSeoPlan(HIGH_ROI_QUERY_SEEDS);
+
+        if (plan.framework !== 'GSD') throw new Error('Framework must be GSD');
+        if (plan.capture.totalKeywords !== HIGH_ROI_QUERY_SEEDS.length) {
+          throw new Error('Capture stage keyword count is incorrect');
+        }
+        if (plan.execute.pages.length < 4) throw new Error('Execute stage must publish at least 4 public pages');
+        if (!plan.review.recommendedOrder.includes('/compare/speclock')) {
+          throw new Error('Recommended order must include /compare/speclock');
+        }
+      },
+    },
+    {
+      id: 'SEO-GSD-02',
+      desc: 'comparison pages stay prioritized ahead of guide pages for bottom-of-funnel demand',
+      fn: () => {
+        delete require.cache[require.resolve('./seo-gsd')];
+        const { THUMBGATE_SEO_PAGE_SPECS } = require('./seo-gsd');
+        const publishOrder = THUMBGATE_SEO_PAGE_SPECS.map((page) => page.path);
+
+        if (publishOrder[0] !== '/compare/speclock') {
+          throw new Error('First publish target must be /compare/speclock');
+        }
+        if (publishOrder[1] !== '/compare/mem0') {
+          throw new Error('Second publish target must be /compare/mem0');
+        }
+        if (new Set(publishOrder).size !== THUMBGATE_SEO_PAGE_SPECS.length) {
+          throw new Error('Public SEO paths must be unique');
+        }
+      },
+    },
+    {
+      id: 'SEO-GSD-03',
+      desc: 'renderSeoPageHtml includes schema, thumbs messaging, and proof-backed CTA links',
+      fn: () => {
+        delete require.cache[require.resolve('./seo-gsd')];
+        const { findSeoPageByPath, renderSeoPageHtml } = require('./seo-gsd');
+        const page = findSeoPageByPath('/compare/speclock');
+        const html = renderSeoPageHtml(page, { appOrigin: 'https://app.example.com' });
+
+        if (!/"@type": "TechArticle"/.test(html)) throw new Error('TechArticle JSON-LD missing');
+        if (!/"@type": "FAQPage"/.test(html)) throw new Error('FAQPage JSON-LD missing');
+        if (!/👍 Thumbs up reinforces good behavior/u.test(html)) {
+          throw new Error('Thumbs-up proof copy missing');
+        }
+        if (!/👎 Thumbs down blocks repeated mistakes/u.test(html)) {
+          throw new Error('Thumbs-down proof copy missing');
+        }
+        if (!/Verification evidence/.test(html) || !/Automation proof/.test(html)) {
+          throw new Error('Proof CTA links missing');
+        }
+      },
+    },
+    {
+      id: 'SEO-GSD-04',
+      desc: 'seo-gsd CLI writes capture, clarify, organize, execute, review, and page-spec outputs',
+      fn: () => {
+        execFileSync(process.execPath, [
+          'scripts/seo-gsd.js',
+          'plan',
+          '--write',
+          `--out-dir=${tmpDir}`,
+        ], {
+          cwd: ROOT,
+          stdio: 'pipe',
+          encoding: 'utf8',
+        });
+
+        const expectedFiles = [
+          '01-capture.json',
+          '02-clarify.json',
+          '03-organize.json',
+          '04-execute-briefs.md',
+          '05-review.json',
+          '06-page-specs.json',
+        ];
+        for (const name of expectedFiles) {
+          if (!fs.existsSync(path.join(tmpDir, name))) {
+            throw new Error(`Missing generated output ${name}`);
+          }
+        }
+      },
+    },
+    {
+      id: 'SEO-GSD-05',
+      desc: 'public sitemap lists the homepage plus every SEO comparison and guide page',
+      fn: () => {
+        delete require.cache[require.resolve('../src/api/server')];
+        const { __test__ } = require('../src/api/server');
+        const sitemap = __test__.renderSitemapXml({ appOrigin: 'https://app.example.com' });
+
+        for (const pathname of [
+          '/',
+          '/compare/speclock',
+          '/compare/mem0',
+          '/guides/pre-action-gates',
+          '/guides/claude-code-feedback',
+        ]) {
+          const loc = pathname === '/'
+            ? '<loc>https://app.example.com/</loc>'
+            : `<loc>https://app.example.com${pathname}</loc>`;
+          if (!sitemap.includes(loc)) {
+            throw new Error(`Sitemap missing ${pathname}`);
+          }
+        }
+      },
+    },
+    {
+      id: 'SEO-GSD-06',
+      desc: 'landing page internally links to the high-intent comparison and guide pages',
+      fn: () => {
+        const landingHtml = fs.readFileSync(path.join(ROOT, 'public', 'index.html'), 'utf8');
+
+        if (!/id="compare-guides"/.test(landingHtml)) {
+          throw new Error('Landing page compare-guides section missing');
+        }
+        for (const pathname of [
+          '/compare/speclock',
+          '/compare/mem0',
+          '/guides/pre-action-gates',
+          '/guides/claude-code-feedback',
+        ]) {
+          if (!landingHtml.includes(`href="${pathname}"`)) {
+            throw new Error(`Landing page missing internal link for ${pathname}`);
+          }
+        }
+      },
+    },
+  ];
+
+  console.log('SEO/GEO GSD - Proof Gate\n');
+  console.log('Checking requirements:\n');
+
+  for (const check of checks) {
+    try {
+      await check.fn();
+      results.passed++;
+      results.requirements[check.id] = { status: 'pass', desc: check.desc };
+      console.log(`  PASS  ${check.id}: ${check.desc}`);
+    } catch (error) {
+      results.failed++;
+      results.requirements[check.id] = {
+        status: 'fail',
+        desc: check.desc,
+        error: error.message,
+      };
+      console.error(`  FAIL  ${check.id}: ${error.message}`);
+    }
+  }
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  fs.mkdirSync(proofDir, { recursive: true });
+
+  const report = {
+    phase: '10-seo-gsd',
+    generatedAt: new Date().toISOString(),
+    passed: results.passed,
+    failed: results.failed,
+    total: checks.length,
+    requirements: results.requirements,
+  };
+
+  fs.writeFileSync(reportJson, JSON.stringify(report, null, 2) + '\n');
+
+  const markdown = [
+    '# SEO/GEO GSD Proof Report',
+    '',
+    `Generated: ${report.generatedAt}`,
+    `Result: ${results.passed}/${checks.length} passed`,
+    '',
+    '## Requirements',
+    '',
+    ...Object.entries(results.requirements).map(([id, requirement]) => {
+      const checkbox = requirement.status === 'pass' ? '[x]' : '[ ]';
+      const errorLine = requirement.error ? `\n  - Error: \`${requirement.error}\`` : '';
+      return `- ${checkbox} **${id}**: ${requirement.desc}${errorLine}`;
+    }),
+    '',
+    `${results.passed} passed, ${results.failed} failed`,
+    '',
+  ].join('\n');
+
+  fs.writeFileSync(reportMd, `${markdown}\n`);
+
+  console.log(`\nResult: ${results.passed} passed, ${results.failed} failed`);
+  console.log(`Report: ${reportJson}`);
+
+  if (results.failed > 0) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  run().catch((error) => {
+    console.error(error.message || String(error));
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  resolveProofPaths,
+  run,
+};

package/scripts/prove-settings.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const SETTINGS_PATH = require.resolve('./settings-hierarchy');
+const PROFILE_ROUTER_PATH = require.resolve('./profile-router');
+const HARNESS_PATH = require.resolve('./natural-language-harness');
+const VERIFY_RUN_PATH = require.resolve('./verify-run');
+const SERVER_STDIO_PATH = require.resolve('../adapters/mcp/server-stdio');
+const DASHBOARD_PATH = require.resolve('./dashboard');
+const TOOL_REGISTRY_PATH = require.resolve('./tool-registry');
+const MCP_ALLOWLISTS_PATH = require.resolve('../config/mcp-allowlists.json');
+
+function resolveProofPaths() {
+  const proofDir = process.env.THUMBGATE_SETTINGS_PROOF_DIR || process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
+  return {
+    proofDir,
+    reportJson: path.join(proofDir, 'settings-report.json'),
+    reportMd: path.join(proofDir, 'settings-report.md'),
+  };
+}
+
+function resetModules() {
+  [
+    SETTINGS_PATH,
+    PROFILE_ROUTER_PATH,
+    HARNESS_PATH,
+    VERIFY_RUN_PATH,
+    SERVER_STDIO_PATH,
+    DASHBOARD_PATH,
+    TOOL_REGISTRY_PATH,
+    MCP_ALLOWLISTS_PATH,
+  ].forEach((modulePath) => {
+    delete require.cache[modulePath];
+  });
+}
+
+function writeJson(filePath, payload) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+}
+
+function makeTempProject(structure = {}) {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-settings-project-'));
+  for (const [relativePath, payload] of Object.entries(structure)) {
+    const fullPath = path.join(projectRoot, relativePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    writeJson(fullPath, payload);
+  }
+  return projectRoot;
+}
+
+function writeReports(results, reportJson, reportMd) {
+  fs.mkdirSync(path.dirname(reportJson), { recursive: true });
+  fs.writeFileSync(reportJson, JSON.stringify(results, null, 2));
+
+  const lines = [
+    '# Settings Hierarchy Proof',
+    '',
+    `- Phase: ${results.phase}`,
+    `- Timestamp: ${results.timestamp}`,
+    `- ${results.passed} passed, ${results.failed} failed`,
+    '',
+    '## Requirements',
+    '',
+  ];
+
+  for (const requirement of Object.values(results.requirements)) {
+    lines.push(`- [${requirement.passed ? 'x' : ' '}] **${requirement.id}** ${requirement.desc}`);
+  }
+
+  fs.writeFileSync(reportMd, `${lines.join('\n')}\n`);
+}
+
+function withClearedEnv(keys, fn) {
+  const previous = new Map(keys.map((key) => [key, process.env[key]]));
+  for (const key of keys) {
+    delete process.env[key];
+  }
+
+  try {
+    return fn();
+  } finally {
+    for (const [key, value] of previous.entries()) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+async function run() {
+  const results = {
+    phase: '24-settings-hierarchy',
+    timestamp: new Date().toISOString(),
+    passed: 0,
+    failed: 0,
+    requirements: {},
+  };
+  const { reportJson, reportMd } = resolveProofPaths();
+
+  const checks = [
+    {
+      id: 'SETTINGS-01',
+      desc: 'managed > local > project > user > defaults precedence resolves correctly',
+      fn: () => {
+        const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-settings-home-'));
+        const projectRoot = makeTempProject({
+          'config/thumbgate-settings.managed.json': { mcp: { defaultProfile: 'locked' } },
+          '.thumbgate/settings.json': { mcp: { defaultProfile: 'dispatch' } },
+          '.thumbgate/settings.local.json': { mcp: { defaultProfile: 'readonly' } },
+        });
+        writeJson(path.join(homeDir, '.thumbgate', 'settings.json'), {
+          mcp: { defaultProfile: 'commerce' },
+        });
+        const { getSetting } = require('./settings-hierarchy');
+        const profile = getSetting('mcp.defaultProfile', { projectRoot, homeDir });
+        if (profile !== 'locked') {
+          throw new Error(`Expected managed profile override, got ${profile}`);
+        }
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+        fs.rmSync(homeDir, { recursive: true, force: true });
+      },
+    },
+    {
+      id: 'SETTINGS-02',
+      desc: 'settings status returns origin metadata for resolved fields',
+      fn: () => {
+        const projectRoot = makeTempProject({
+          'config/thumbgate-settings.managed.json': { dashboard: { showPolicyOrigins: true } },
+        });
+        const { getSettingsStatus } = require('./settings-hierarchy');
+        const status = getSettingsStatus({ projectRoot, homeDir: projectRoot });
+        const origin = status.origins.find((entry) => entry.path === 'dashboard.showPolicyOrigins');
+        if (!origin || origin.scope !== 'managed') {
+          throw new Error('Expected managed origin for dashboard.showPolicyOrigins');
+        }
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+      },
+    },
+    {
+      id: 'SETTINGS-03',
+      desc: 'profile routing uses settings fallback when env override is absent',
+      fn: () => {
+        const projectRoot = makeTempProject({
+          'config/thumbgate-settings.managed.json': { mcp: { defaultProfile: 'dispatch' } },
+        });
+        try {
+          const routed = withClearedEnv(
+            ['THUMBGATE_MCP_PROFILE', 'CI', 'GITHUB_EVENT_NAME', 'THUMBGATE_SESSION_TYPE', 'THUMBGATE_SUBAGENT_PROFILE'],
+            () => {
+              const { routeProfile } = require('./profile-router');
+              return routeProfile({ settingsOptions: { projectRoot, homeDir: projectRoot } });
+            },
+          );
+          if (routed.profile !== 'dispatch') {
+            throw new Error(`Expected dispatch profile from settings, got ${routed.profile}`);
+          }
+        } finally {
+          fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      id: 'SETTINGS-04',
+      desc: 'harness execution is blocked when runtime execution is disabled by settings',
+      fn: () => {
+        const projectRoot = makeTempProject({
+          '.thumbgate/settings.json': { harnesses: { allowRuntimeExecution: false } },
+        });
+        const { runHarness } = require('./natural-language-harness');
+        let blocked = false;
+        try {
+          runHarness('repo-full-verification', {}, {
+            settingsOptions: { projectRoot, homeDir: projectRoot },
+          });
+        } catch (error) {
+          blocked = /disabled by the settings hierarchy/i.test(error.message);
+        }
+        if (!blocked) {
+          throw new Error('Expected harness execution to be blocked by settings');
+        }
+        fs.rmSync(projectRoot, { recursive: true, force: true });
+      },
+    },
+    {
+      id: 'SETTINGS-05',
+      desc: 'dashboard and MCP surfaces expose settings status visibility',
+      fn: () => {
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-settings-dashboard-'));
+        const { generateDashboard } = require('./dashboard');
+        const dashboard = generateDashboard(feedbackDir);
+        const { TOOLS } = require('./tool-registry');
+        const mcpAllowlists = require('../config/mcp-allowlists.json');
+
+        try {
+          if (!dashboard.settingsStatus || !dashboard.settingsStatus.resolvedSettings) {
+            throw new Error('Dashboard is missing settingsStatus');
+          }
+
+          const settingsTool = TOOLS.find((tool) => tool.name === 'settings_status');
+          if (!settingsTool) {
+            throw new Error('settings_status tool is missing from the registry');
+          }
+
+          const defaultAllowlist = mcpAllowlists.profiles && mcpAllowlists.profiles.default;
+          if (!Array.isArray(defaultAllowlist) || !defaultAllowlist.includes('settings_status')) {
+            throw new Error('settings_status is missing from the default MCP allowlist');
+          }
+        } finally {
+          fs.rmSync(feedbackDir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      id: 'SETTINGS-06',
+      desc: 'verify:full includes settings proof and materializes the artifact',
+      fn: () => {
+        const { buildVerifyPlan, recordVerifyWorkflowRun } = require('./verify-run');
+        const plan = buildVerifyPlan('full');
+        if (!plan.some((step) => Array.isArray(step.args) && step.args.includes('prove:settings'))) {
+          throw new Error('verify:full is missing prove:settings');
+        }
+        const feedbackDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-settings-proof-run-'));
+        try {
+          const workflowRun = recordVerifyWorkflowRun('full', ROOT, feedbackDir);
+          if (!workflowRun.proofArtifacts.some((artifact) => artifact.endsWith(path.join('proof', 'settings-report.json')))) {
+            throw new Error('Workflow run is missing settings proof artifact');
+          }
+        } finally {
+          fs.rmSync(feedbackDir, { recursive: true, force: true });
+        }
+      },
+    },
+  ];
+
+  for (const check of checks) {
+    try {
+      resetModules();
+      await check.fn();
+      results.passed += 1;
+      results.requirements[check.id] = { id: check.id, desc: check.desc, passed: true };
+    } catch (error) {
+      results.failed += 1;
+      results.requirements[check.id] = {
+        id: check.id,
+        desc: check.desc,
+        passed: false,
+        error: error.message,
+      };
+    } finally {
+      resetModules();
+    }
+  }
+
+  writeReports(results, reportJson, reportMd);
+  console.log(`${results.passed} passed, ${results.failed} failed`);
+  if (results.failed > 0) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  run().catch((error) => {
+    console.error(error.stack || error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  resolveProofPaths,
+  run,
+};