thumbgate 1.15.0 → 1.16.1

package/scripts/private-core-boundary.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const path = require('node:path');
+
+function normalizeRequest(request) {
+  return String(request || '').trim();
+}
+
+function isOptionalModuleMissing(error, request) {
+  if (!error || error.code !== 'MODULE_NOT_FOUND') {
+    return false;
+  }
+  const message = String(error?.message || '');
+  const normalizedRequest = normalizeRequest(request);
+  const basename = path.basename(normalizedRequest);
+  return [normalizedRequest, basename]
+    .filter(Boolean)
+    .some((candidate) => message.includes(candidate));
+}
+
+function loadOptionalModule(request, fallbackFactory) {
+  try {
+    return require(request);
+  } catch (error) {
+    if (!isOptionalModuleMissing(error, request)) {
+      throw error;
+    }
+    return typeof fallbackFactory === 'function'
+      ? fallbackFactory(error)
+      : (fallbackFactory || {});
+  }
+}
+
+function createUnavailableError(feature, options = {}) {
+  const err = new Error(
+    `${feature} moved behind the ThumbGate-Core boundary and is unavailable in the public thumbgate package.`
+  );
+  err.code = 'THUMBGATE_CORE_REQUIRED';
+  err.statusCode = options.statusCode || 503;
+  err.feature = feature;
+  return err;
+}
+
+function createUnavailableOperation(feature, options = {}) {
+  return function unavailableOperation() {
+    throw createUnavailableError(feature, options);
+  };
+}
+
+function createUnavailableAsyncOperation(feature, options = {}) {
+  return async function unavailableAsyncOperation() {
+    throw createUnavailableError(feature, options);
+  };
+}
+
+function createUnavailableReport(feature, extra = {}) {
+  return {
+    available: false,
+    source: 'ThumbGate-Core',
+    message: `${feature} requires ThumbGate-Core.`,
+    ...extra,
+  };
+}
+
+module.exports = {
+  createUnavailableAsyncOperation,
+  createUnavailableError,
+  createUnavailableOperation,
+  createUnavailableReport,
+  isOptionalModuleMissing,
+  loadOptionalModule,
+};

package/scripts/production-agent-readiness.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+'use strict';
+
+function readinessStatus(score, missing) {
+  if (missing.length === 0) return 'production_ready';
+  if (score >= 60) return 'needs_hardening';
+  return 'prototype';
+}
+
+function evaluateProductionAgentReadiness(input = {}) {
+  const signals = {
+    subAgents: Array.isArray(input.subAgents) && input.subAgents.length >= 2,
+    structuredOutputs: input.structuredOutputs === true,
+    dynamicRag: input.dynamicRag === true,
+    observability: input.observability === true || input.tracing === true,
+    circuitBreakers: input.circuitBreakers === true,
+  };
+  const missing = Object.entries(signals)
+    .filter(([, present]) => !present)
+    .map(([name]) => name);
+  const score = Math.round((Object.values(signals).filter(Boolean).length / Object.keys(signals).length) * 100);
+  return {
+    status: readinessStatus(score, missing),
+    score,
+    signals,
+    missing,
+    requiredFixes: missing.map((name) => ({
+      subAgents: 'Split monolithic prompts into narrow sub-agent stages.',
+      structuredOutputs: 'Use runtime-validated schemas instead of prompt-only JSON formatting.',
+      dynamicRag: 'Replace hardcoded context with refreshed retrieval over indexed source material.',
+      observability: 'Emit traces for model calls, tool calls, tokens, latency, and stage failures.',
+      circuitBreakers: 'Set retry, timeout, loop, and spend limits before production use.',
+    }[name])),
+  };
+}
+
+module.exports = {
+  evaluateProductionAgentReadiness,
+  readinessStatus,
+};