thumbgate 1.30.0 → 1.31.0

package/scripts/tool-registry.js

@@ -248,6 +248,20 @@ const TOOLS = [
         scope: MEMORY_SCOPE_SCHEMA,
         requireScope: { type: 'boolean', description: 'Fail closed unless a complete four-field scope is supplied.' },
         includeShared: { type: 'boolean', description: 'Include explicitly shared memories with scoped results. Defaults true.' },
+        filters: {
+          type: 'object',
+          description: 'Pre-filter the candidate corpus before lexical or vector ranking.',
+          properties: {
+            domain: { type: ['string', 'array'], items: { type: 'string' } },
+            signal: { type: ['string', 'array'], items: { type: 'string' } },
+            source: { type: ['string', 'array'], items: { type: 'string' } },
+            toolsUsed: { type: ['string', 'array'], items: { type: 'string' } },
+            tags: { type: 'array', items: { type: 'string' } },
+            requireAllTags: { type: 'boolean' },
+          },
+        },
+        queryRewrite: { type: 'boolean', description: 'Enable bounded deterministic synonym expansion when the original lexical match is weak. Defaults true.' },
+        includeRetrievalMeta: { type: 'boolean', description: 'Include path provenance such as lexical/dense pools and query variants.' },
       },
       required: ['toolName'],
     },
@@ -276,6 +290,17 @@ const TOOLS = [
         limit: { type: 'number', description: 'Maximum results to return (default 10)' },
         source: { type: 'string', enum: ['all', 'feedback', 'context', 'rules', 'documents'], description: 'Restrict search to a single ThumbGate source.' },
         signal: { type: 'string', enum: ['up', 'down', 'positive', 'negative'], description: 'Optional feedback-signal filter when searching feedback data.' },
+        filters: {
+          type: 'object',
+          description: 'Pre-filter imported documents before chunk ranking.',
+          properties: {
+            tags: { type: 'array', items: { type: 'string' } },
+            requireAllTags: { type: 'boolean' },
+            sourceFormat: { type: 'string' },
+            sourceType: { type: 'string' },
+          },
+        },
+        queryRewrite: { type: 'boolean', description: 'Enable bounded deterministic synonym expansion. Defaults true.' },
       },
     },
   }),
@@ -1285,6 +1310,27 @@ const TOOLS = [
       },
     },
   }),
+  readOnlyTool({
+    name: 'gate_check',
+    // Harnesses with a native pre-tool hook (Claude Code, Codex, Gemini, Forge) get hard
+    // enforcement and never need this. MCP-only harnesses (Cline, Cursor, OpenCode) have no
+    // interception point, so this exposes the SAME gates engine as a tool the agent calls
+    // before acting. adapters/cline/.clinerules has instructed agents to call
+    // `thumbgate.gate_check` since the adapter shipped — but the tool did not exist, so
+    // that enforcement was inert. This makes the documented contract real.
+    description: 'Evaluate a proposed tool call against ThumbGate policy BEFORE executing it. Returns decision "block" (do not run the action; surface the reason) or "allow". Use this when about to run a shell command, write/edit a file, or take any irreversible action.',
+    inputSchema: {
+      type: 'object',
+      required: ['tool_name'],
+      properties: {
+        tool_name: { type: 'string', description: 'The tool about to be invoked (e.g. Bash, Write, Edit)' },
+        tool_input: {
+          type: 'object',
+          description: 'The proposed arguments, e.g. { "command": "rm -rf /" } for Bash or { "file_path": "..." } for Write',
+        },
+      },
+    },
+  }),
   readOnlyTool({
     name: 'gate_stats',
     description: 'Get gate enforcement statistics -- blocked count, warned count, top gates',

package/scripts/vector-store.js

@@ -80,6 +80,42 @@ function hasLocalTransformerProvider() {
   }
 }
 
+function getOllamaEmbeddingConfig() {
+  const model = String(process.env.THUMBGATE_OLLAMA_EMBED_MODEL || '').trim();
+  let endpoint = String(
+    process.env.THUMBGATE_OLLAMA_ENDPOINT
+    || process.env.OLLAMA_HOST
+    || 'http://127.0.0.1:11434',
+  ).trim();
+  if (endpoint && !/^https?:\/\//i.test(endpoint)) endpoint = `http://${endpoint}`;
+  while (endpoint.endsWith('/')) endpoint = endpoint.slice(0, -1);
+  return {
+    enabled: Boolean(model),
+    model,
+    endpoint,
+    timeoutMs: Math.max(
+      250,
+      Math.min(30_000, Number(process.env.THUMBGATE_OLLAMA_TIMEOUT_MS) || 10_000),
+    ),
+  };
+}
+
+/**
+ * Synchronous capability check used by hot-path routing. This reports only
+ * semantic providers, never the deterministic feature-hash degradation.
+ */
+function hasSemanticEmbeddingProvider() {
+  if (process.env.THUMBGATE_VECTOR_STUB_EMBED === 'true') return true;
+  if (getOllamaEmbeddingConfig().enabled) return true;
+  if (hasLocalTransformerProvider()) return true;
+  try {
+    const config = resolveGeminiEmbeddingConfig();
+    return config.provider === 'coreai' || Boolean(config.enabled && config.apiKey);
+  } catch {
+    return false;
+  }
+}
+
 function fnv1a32(value) {
   let hash = 0x811c9dc5;
   const bytes = Buffer.from(String(value), 'utf8');
@@ -98,7 +134,7 @@ function addHashedFeature(vector, feature, weight) {
 }
 
 function embedWithFeatureHash(text) {
-  const vector = Array(FEATURE_HASH_DIMENSIONS).fill(0);
+  const vector = new Array(FEATURE_HASH_DIMENSIONS).fill(0);
   const tokens = String(text || '').toLowerCase().match(/[\p{L}\p{N}_-]+/gu) || [];
 
   for (let index = 0; index < tokens.length; index += 1) {
@@ -249,6 +285,43 @@ async function embedWithCoreAI(text, options = {}) {
   throw new Error('Core AI local service did not return a valid embedding');
 }
 
+async function embedWithOllama(text, options = {}) {
+  const config = getOllamaEmbeddingConfig();
+  if (!config.enabled) {
+    throw new Error('Ollama embeddings require THUMBGATE_OLLAMA_EMBED_MODEL');
+  }
+  if (typeof fetch !== 'function') {
+    throw new Error('Ollama embeddings require global fetch. Use Node 18.18+.');
+  }
+
+  let response;
+  try {
+    response = await fetch(`${config.endpoint}/api/embed`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: config.model,
+        input: String(text || ''),
+        truncate: true,
+        dimensions: options.outputDimensionality || undefined,
+      }),
+      signal: AbortSignal.timeout(config.timeoutMs),
+    });
+  } catch (error) {
+    throw new Error(`Ollama embedding service unavailable: ${error.message}`);
+  }
+
+  if (!response.ok) {
+    throw new Error(`Ollama embedding request failed: ${response.status} ${response.statusText}`);
+  }
+  const payload = await response.json();
+  const vector = Array.isArray(payload.embeddings) ? payload.embeddings[0] : null;
+  if (!Array.isArray(vector) || vector.length === 0) {
+    throw new Error('Ollama embedding response did not include vector values');
+  }
+  return vector.map(Number);
+}
+
 async function embed(text, options = {}) {
   if (process.env.THUMBGATE_VECTOR_STUB_EMBED === 'true') {
     // Deterministic 384-dim unit vector: first element = 1.0, rest = 0.0
@@ -277,6 +350,28 @@ async function embed(text, options = {}) {
       console.warn(`Core AI embedding failed, falling back to local: ${coreaiError.message}`);
     }
   }
+  const ollamaConfig = getOllamaEmbeddingConfig();
+  if (ollamaConfig.enabled) {
+    try {
+      const vector = await embedWithOllama(text, options);
+      _lastEmbeddingProfile = {
+        generatedAt: new Date().toISOString(),
+        source: 'local-ollama',
+        activeProfile: {
+          id: 'ollama',
+          model: ollamaConfig.model,
+          outputDimensionality: vector.length,
+          task: options.task || 'code retrieval',
+          rationale: 'Explicit local Ollama semantic embedding provider.',
+          qualityTier: 'production',
+        },
+        fallbackUsed: false,
+      };
+      return vector;
+    } catch (ollamaError) {
+      console.warn(`Ollama embedding failed, falling back: ${ollamaError.message}`);
+    }
+  }
   if (geminiConfig.enabled) {
     try {
       const vector = await embedWithGemini(text, options);
@@ -297,7 +392,9 @@ async function embed(text, options = {}) {
       if (!geminiConfig.fallbackToLocal) {
         throw geminiError;
       }
-      console.warn(`Gemini embedding fallback: ${geminiError.message}`);
+      // Do not log raw provider/user-controlled error text (Sonar jssecurity:S5145).
+      const code = geminiError && (geminiError.code || geminiError.name || 'Error');
+      console.warn(`Gemini embedding fallback: ${code}`);
     }
   }
   if (hasLocalTransformerProvider()) {
@@ -314,6 +411,8 @@ async function embed(text, options = {}) {
   }
 
   const vector = embedWithFeatureHash(text);
+  // Feature-hash is a last-resort degrade, not production semantic quality.
+  // Callers (prove/eval/chat health) must treat quality_tier=degraded.
   _lastEmbeddingProfile = {
     generatedAt: new Date().toISOString(),
     source: 'built-in',
@@ -322,9 +421,11 @@ async function embed(text, options = {}) {
       model: 'ThumbGate feature hashing',
       outputDimensionality: FEATURE_HASH_DIMENSIONS,
       task: options.task || 'code retrieval',
-      rationale: 'Deterministic zero-dependency local text embedding.',
+      rationale: 'DEGRADED: deterministic zero-dependency hash embedding — not semantic. Configure Gemini or local transformers for production retrieval quality.',
+      qualityTier: 'degraded',
     },
-    fallbackUsed: false,
+    fallbackUsed: true,
+    fallbackReason: 'no_managed_or_transformer_embedder',
   };
   return vector;
 }
@@ -440,4 +541,7 @@ module.exports = {
   setGeminiEmbedderForTests,
   truncateForEmbedding,
   embedWithFeatureHash,
+  embedWithOllama,
+  getOllamaEmbeddingConfig,
+  hasSemanticEmbeddingProvider,
 };

package/scripts/verify-marketing-pages-deployed.js

@@ -22,6 +22,8 @@
  *   --json    machine-readable report on stdout, suitable for piping
  *             into the GitHub Actions PR comment step.
  *   --quiet   suppress per-route lines; only print the final summary.
+ *   --max-attempts=N     retry only transient transport/5xx failures.
+ *   --retry-delay-ms=N   bounded delay between transient retries.
  *
  * Exit code is 0 when every page passes, 1 if any sentinel is missing
  * or any route returns non-200.
@@ -32,6 +34,8 @@ const path = require('node:path');
 
 const DEFAULT_PROD_URL = 'https://thumbgate-production.up.railway.app';
 const DEFAULT_TIMEOUT_MS = 12000;
+const DEFAULT_MAX_ATTEMPTS = 2;
+const DEFAULT_RETRY_DELAY_MS = 500;
 const DEFAULT_MANIFEST_PATH = path.resolve(__dirname, '..', 'config', 'post-deploy-marketing-pages.json');
 
 function parseArgs(argv = []) {
@@ -41,6 +45,8 @@ function parseArgs(argv = []) {
     json: false,
     quiet: false,
     timeoutMs: DEFAULT_TIMEOUT_MS,
+    maxAttempts: DEFAULT_MAX_ATTEMPTS,
+    retryDelayMs: DEFAULT_RETRY_DELAY_MS,
   };
   for (const arg of argv) {
     if (arg === '--json') out.json = true;
@@ -50,6 +56,12 @@ function parseArgs(argv = []) {
     else if (arg.startsWith('--timeout-ms=')) {
       const n = Number(arg.slice('--timeout-ms='.length));
       if (Number.isFinite(n) && n > 0) out.timeoutMs = n;
+    } else if (arg.startsWith('--max-attempts=')) {
+      const n = Number(arg.slice('--max-attempts='.length));
+      if (Number.isInteger(n) && n > 0 && n <= 5) out.maxAttempts = n;
+    } else if (arg.startsWith('--retry-delay-ms=')) {
+      const n = Number(arg.slice('--retry-delay-ms='.length));
+      if (Number.isInteger(n) && n >= 0 && n <= 5000) out.retryDelayMs = n;
     }
   }
   return out;
@@ -80,7 +92,7 @@ function loadManifest(manifestPath) {
   return parsed;
 }
 
-async function probePage({ prodUrl, route, sentinel, mustNotContain = [], userAgent, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+async function probePageOnce({ prodUrl, route, sentinel, mustNotContain = [], userAgent, fetchImpl, timeoutMs }) {
   if (typeof fetchImpl !== 'function') {
     return { route, ok: false, error: 'fetch_unavailable' };
   }
@@ -97,7 +109,10 @@ async function probePage({ prodUrl, route, sentinel, mustNotContain = [], userAg
         Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
       },
     });
-    const body = await res.text().catch(() => '');
+    // Keep body-read transport failures visible to the outer retry classifier.
+    // Treating a disconnected 2xx stream as an empty body would incorrectly
+    // turn an operational failure into a deterministic sentinel mismatch.
+    const body = await res.text();
     const sentinelPresent = body.includes(sentinel);
     const forbiddenPresent = Array.isArray(mustNotContain)
       ? mustNotContain.filter((value) => body.includes(value))
@@ -122,7 +137,67 @@ async function probePage({ prodUrl, route, sentinel, mustNotContain = [], userAg
   }
 }
 
-async function runVerification({ prodUrl, manifestPath, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+function isTransientProbeFailure(result = {}) {
+  if (result.ok) return false;
+  if (result.error && result.error !== 'fetch_unavailable') return true;
+  return result.status === 429 || result.status >= 500;
+}
+
+function waitForRetry(delayMs) {
+  if (!delayMs) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
+async function probePage({
+  prodUrl,
+  route,
+  sentinel,
+  mustNotContain = [],
+  userAgent,
+  fetchImpl = globalThis.fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  maxAttempts = DEFAULT_MAX_ATTEMPTS,
+  retryDelayMs = DEFAULT_RETRY_DELAY_MS,
+}) {
+  const boundedAttempts = Number.isInteger(maxAttempts)
+    ? Math.min(Math.max(maxAttempts, 1), 5)
+    : DEFAULT_MAX_ATTEMPTS;
+  let result;
+  for (let attempt = 1; attempt <= boundedAttempts; attempt += 1) {
+    // eslint-disable-next-line no-await-in-loop
+    result = await probePageOnce({
+      prodUrl,
+      route,
+      sentinel,
+      mustNotContain,
+      userAgent,
+      fetchImpl,
+      timeoutMs,
+    });
+    if (!isTransientProbeFailure(result) || attempt === boundedAttempts) {
+      return {
+        ...result,
+        attempts: attempt,
+        recoveredAfterRetry: Boolean(result.ok && attempt > 1),
+      };
+    }
+    // A deploy can pass /health while the first buyer-page request still
+    // wakes a cold instance. Retry only transient failures; content contract
+    // mismatches remain immediate, deterministic failures.
+    // eslint-disable-next-line no-await-in-loop
+    await waitForRetry(retryDelayMs);
+  }
+  return { ...result, attempts: boundedAttempts, recoveredAfterRetry: false };
+}
+
+async function runVerification({
+  prodUrl,
+  manifestPath,
+  fetchImpl = globalThis.fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  maxAttempts = DEFAULT_MAX_ATTEMPTS,
+  retryDelayMs = DEFAULT_RETRY_DELAY_MS,
+} = {}) {
   const manifest = loadManifest(manifestPath);
   const results = [];
   // Sequential is fine — manifest has <20 entries; parallelism would
@@ -137,6 +212,8 @@ async function runVerification({ prodUrl, manifestPath, fetchImpl = globalThis.f
       userAgent: entry.userAgent,
       fetchImpl,
       timeoutMs,
+      maxAttempts,
+      retryDelayMs,
     });
     results.push({ ...result, sentinel: entry.sentinel, description: entry.description });
   }
@@ -183,6 +260,8 @@ async function main(argv) {
       prodUrl: args.prodUrl,
       manifestPath: args.manifestPath,
       timeoutMs: args.timeoutMs,
+      maxAttempts: args.maxAttempts,
+      retryDelayMs: args.retryDelayMs,
     });
   } catch (error) {
     process.stderr.write(`verify-marketing-pages-deployed FAILED: ${error.message}\n`);
@@ -199,9 +278,12 @@ async function main(argv) {
 module.exports = {
   DEFAULT_PROD_URL,
   DEFAULT_TIMEOUT_MS,
+  DEFAULT_MAX_ATTEMPTS,
+  DEFAULT_RETRY_DELAY_MS,
   DEFAULT_MANIFEST_PATH,
   parseArgs,
   loadManifest,
+  isTransientProbeFailure,
   probePage,
   runVerification,
   renderHuman,

package/server.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.IgorGanapolsky/thumbgate",
+  "description": "ThumbGate pre-action gates for AI coding agents. Captures thumbs-up/down feedback as lessons, promotes repeated failures into prevention rules, and evaluates tool calls over stdio MCP before they run.",
+  "title": "ThumbGate",
+  "websiteUrl": "https://thumbgate.ai",
+  "repository": {
+    "source": "github",
+    "url": "https://github.com/IgorGanapolsky/ThumbGate"
+  },
+  "version": "1.31.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "registryBaseUrl": "https://registry.npmjs.org",
+      "identifier": "thumbgate",
+      "version": "1.31.0",
+      "runtimeHint": "npx",
+      "runtimeArguments": [
+        {
+          "type": "positional",
+          "value": "-y"
+        }
+      ],
+      "packageArguments": [
+        {
+          "type": "positional",
+          "value": "serve"
+        }
+      ],
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "THUMBGATE_MCP_PROFILE",
+          "description": "Optional MCP tool profile override (essential | default | readonly | locked). Omit to keep the factory least-privilege essential profile; only set when expanded tools are intentional.",
+          "isRequired": false,
+          "format": "string"
+        }
+      ]
+    }
+  ]
+}

package/smithery.yaml

@@ -0,0 +1,17 @@
+startCommand:
+  type: "stdio"
+  configSchema:
+    type: "object"
+    properties:
+      mcpProfile:
+        type: "string"
+        description: "MCP profile to use (default, readonly, locked)"
+        default: "default"
+    required: []
+  commandFunction:
+    command: "npx"
+    args:
+      - "-y"
+      - "thumbgate"
+      - "serve"
+description: "ThumbGate — pre-action gates for AI coding agents. Turns thumbs-down feedback into prevention rules and evaluates tool calls over stdio MCP (npx -y thumbgate serve) before they run. Not the HTTP API (npm start). Works with Claude Code, Cursor, Codex, Gemini CLI, Amp, OpenCode, and any MCP-compatible agent."