thumbgate 0.9.10

package/scripts/lesson-synthesis.js

@@ -0,0 +1,196 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const SIMILARITY_THRESHOLD = 0.6;
+const AUTO_PROMOTE_THRESHOLD = 3;
+
+/**
+ * Read JSONL file and return parsed records.
+ * Self-contained to avoid circular dependency with feedback-loop.
+ */
+function readJSONLLocal(filePath, { maxLines = 500 } = {}) {
+  if (!fs.existsSync(filePath)) return [];
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n').filter(Boolean);
+  const tail = maxLines > 0 ? lines.slice(-maxLines) : lines;
+  const results = [];
+  for (const line of tail) {
+    try { results.push(JSON.parse(line)); } catch { /* skip malformed */ }
+  }
+  return results;
+}
+
+/**
+ * Append a record to a JSONL file.
+ */
+function appendJSONLLocal(filePath, record) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`);
+}
+
+/**
+ * Find a similar existing lesson by comparing titles and context.
+ * Uses token overlap (Jaccard similarity) — fast, no embeddings needed.
+ */
+function findSimilarLesson(memoryLogPath, newRecord) {
+  const existing = readJSONLLocal(memoryLogPath, { maxLines: 200 });
+  const newTokens = tokenize(newRecord.title + ' ' + (newRecord.content || ''));
+
+  let bestMatch = null;
+  let bestScore = 0;
+
+  for (const mem of existing) {
+    const memTokens = tokenize((mem.title || '') + ' ' + (mem.content || ''));
+    const score = jaccardSimilarity(newTokens, memTokens);
+    if (score > bestScore && score >= SIMILARITY_THRESHOLD) {
+      bestScore = score;
+      bestMatch = mem;
+    }
+  }
+
+  return bestMatch ? { match: bestMatch, similarity: bestScore } : null;
+}
+
+/**
+ * Merge a new feedback event into an existing lesson.
+ * Increments occurrence count, updates timestamp, enriches context.
+ */
+function mergeIntoExisting(memoryLogPath, existingLesson, newRecord, newFeedbackEvent) {
+  const merged = {
+    ...existingLesson,
+    occurrences: (existingLesson.occurrences || 1) + 1,
+    lastUpdated: new Date().toISOString(),
+    mergedFeedbackIds: [
+      ...(existingLesson.mergedFeedbackIds || []),
+      newFeedbackEvent.id
+    ].slice(-20), // Keep last 20 IDs
+  };
+
+  // Enrich context if the new one adds information
+  if (newRecord.content && newRecord.content.length > (existingLesson.content || '').length) {
+    merged.content = newRecord.content;
+  }
+
+  // Update the record in-place by rewriting the JSONL
+  updateRecordInJsonl(memoryLogPath, existingLesson.id, merged);
+
+  return merged;
+}
+
+/**
+ * Check if a lesson should be auto-promoted to a prevention rule.
+ * Threshold: 3+ occurrences.
+ */
+function shouldAutoPromote(lesson) {
+  return (lesson.occurrences || 1) >= AUTO_PROMOTE_THRESHOLD;
+}
+
+/**
+ * Generate a structured prevention rule from a high-frequency lesson.
+ */
+function synthesizePreventionRule(lesson) {
+  const title = lesson.title || '';
+  const content = lesson.content || '';
+
+  // Extract the core mistake pattern
+  const mistakeMatch = title.match(/^MISTAKE:\s*(.+)/i);
+  const mistake = mistakeMatch ? mistakeMatch[1].trim() : title;
+
+  // Build IF/THEN rule
+  return {
+    id: 'synth_' + Date.now() + '_' + Math.random().toString(36).slice(2, 6),
+    type: 'auto-promoted',
+    source: 'lesson-synthesis',
+    sourceLessonId: lesson.id,
+    occurrences: lesson.occurrences || 1,
+    rule: {
+      format: 'if-then-v1',
+      trigger: { condition: mistake, type: 'recurring-mistake' },
+      action: { type: 'avoid', description: 'NEVER: ' + mistake },
+      confidence: Math.min(0.5 + (lesson.occurrences || 1) * 0.1, 0.95),
+      scope: inferScopeFromTags(lesson.tags || []),
+    },
+    humanReadable: 'After ' + (lesson.occurrences || 1) + ' occurrences: NEVER ' + mistake,
+    tags: [...(lesson.tags || []), 'auto-promoted', 'synthesized'],
+    createdAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Update a single record in a JSONL file by ID.
+ */
+function updateRecordInJsonl(filePath, recordId, updatedRecord) {
+  if (!fs.existsSync(filePath)) return false;
+  const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+  let found = false;
+  const updated = lines.map(function(line) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.id === recordId) {
+        found = true;
+        return JSON.stringify(updatedRecord);
+      }
+      return line;
+    } catch { return line; }
+  });
+  if (found) {
+    fs.writeFileSync(filePath, updated.join('\n') + '\n');
+  }
+  return found;
+}
+
+/**
+ * Delete a single record from a JSONL file by ID.
+ */
+function deleteRecordFromJsonl(filePath, recordId) {
+  if (!fs.existsSync(filePath)) return false;
+  const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+  const filtered = lines.filter(function(line) {
+    try {
+      const obj = JSON.parse(line);
+      return obj.id !== recordId;
+    } catch { return true; }
+  });
+  if (filtered.length === lines.length) return false;
+  fs.writeFileSync(filePath, filtered.length ? filtered.join('\n') + '\n' : '');
+  return true;
+}
+
+function tokenize(text) {
+  return (text || '').toLowerCase().split(/[\s.,;:!?()\[\]{}"'`]+/).filter(function(t) { return t.length > 3; });
+}
+
+function jaccardSimilarity(setA, setB) {
+  var a = new Set(setA);
+  var b = new Set(setB);
+  var intersection = 0;
+  a.forEach(function(item) { if (b.has(item)) intersection++; });
+  var union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function inferScopeFromTags(tags) {
+  if (tags.some(function(t) { return t.includes('file') || t.includes('src/'); })) return 'file-level';
+  if (tags.some(function(t) { return t.includes('project') || t.includes('repo'); })) return 'project-level';
+  return 'global';
+}
+
+module.exports = {
+  findSimilarLesson,
+  mergeIntoExisting,
+  shouldAutoPromote,
+  synthesizePreventionRule,
+  updateRecordInJsonl,
+  deleteRecordFromJsonl,
+  readJSONLLocal,
+  appendJSONLLocal,
+  jaccardSimilarity,
+  tokenize,
+  inferScopeFromTags,
+  SIMILARITY_THRESHOLD,
+  AUTO_PROMOTE_THRESHOLD,
+};

package/scripts/license.js

@@ -0,0 +1,50 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const LICENSE_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.thumbgate', 'license.json');
+const VALID_PREFIXES = ['tg_pro_', 'tg_'];
+
+function isValidKey(key) {
+  return key && VALID_PREFIXES.some((p) => key.startsWith(p));
+}
+
+function verifyLicense() {
+  const envKey = process.env.THUMBGATE_API_KEY || process.env.THUMBGATE_PRO_KEY;
+  if (isValidKey(envKey)) {
+    return { valid: true, source: 'env', key: envKey };
+  }
+  try {
+    if (fs.existsSync(LICENSE_PATH)) {
+      const data = JSON.parse(fs.readFileSync(LICENSE_PATH, 'utf8'));
+      if (isValidKey(data.key)) {
+        return { valid: true, source: 'file', key: data.key, activatedAt: data.activatedAt };
+      }
+    }
+  } catch (_) {}
+  return { valid: false, source: null };
+}
+
+function isProLicensed() {
+  return verifyLicense().valid;
+}
+
+function activateLicense(key) {
+  if (!isValidKey(key)) {
+    return { success: false, error: 'Invalid key format. Expected tg_... or tg_pro_...' };
+  }
+  const dir = path.dirname(LICENSE_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const data = { key, activatedAt: new Date().toISOString(), version: require('../package.json').version };
+  fs.writeFileSync(LICENSE_PATH, JSON.stringify(data, null, 2));
+  return { success: true, path: LICENSE_PATH };
+}
+
+function generateLicenseKey(email) {
+  const payload = `${email}:${Date.now()}`;
+  const hash = crypto.createHash('sha256').update(payload).digest('hex').slice(0, 24);
+  return `tg_pro_${hash}`;
+}
+
+module.exports = { verifyLicense, isProLicensed, activateLicense, generateLicenseKey, isValidKey, VALID_PREFIXES, LICENSE_PATH };

package/scripts/local-model-profile.js

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const DEFAULT_FEEDBACK_DIR = path.join(PROJECT_ROOT, '.claude', 'memory', 'feedback');
+const DEFAULT_EMBED_MODEL = 'Xenova/all-MiniLM-L6-v2';
+
+// ---------------------------------------------------------------------------
+// Model Role Router (OpenDev workload-specialized model routing)
+// ---------------------------------------------------------------------------
+
+const MODEL_ROLES = {
+  normal: 'gemini-2.5-flash',
+  thinking: 'gemini-2.5-pro',
+  critique: 'gemini-2.5-flash',
+  compaction: 'gemini-2.5-flash-lite',
+  vlm: 'gemini-2.5-flash',
+};
+
+const VALID_MODEL_ROLES = Object.keys(MODEL_ROLES);
+
+const EMBEDDING_PROFILES = {
+  compact: {
+    id: 'compact',
+    model: DEFAULT_EMBED_MODEL,
+    quantized: true,
+    maxChars: 1024,
+    rationale: 'Conservative fit for low-memory or CI environments.',
+  },
+  balanced: {
+    id: 'balanced',
+    model: DEFAULT_EMBED_MODEL,
+    quantized: true,
+    maxChars: 2048,
+    rationale: 'Default local profile for reliable quantized embedding.',
+  },
+  quality: {
+    id: 'quality',
+    model: DEFAULT_EMBED_MODEL,
+    quantized: false,
+    maxChars: 4096,
+    rationale: 'Higher-quality local embedding when memory headroom is available.',
+  },
+};
+
+const INDEXCACHE_SERVER_ENGINES = new Set([
+  'sglang',
+  'vllm',
+  'trtllm',
+  'tensorrt-llm',
+]);
+
+const LONG_CONTEXT_TASK_TYPES = new Set([
+  'architecture',
+  'cross-file',
+  'large-context',
+]);
+
+const LONG_CONTEXT_TAGS = new Set([
+  'codegraph',
+  'contextfs',
+  'long-context',
+  'multi-hop',
+  'retrieval-heavy',
+  'xmemory',
+]);
+
+function parseNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function parseBoolean(value, fallback) {
+  if (value == null || value === '') return fallback;
+  if (typeof value === 'boolean') return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'off'].includes(normalized)) return false;
+  return fallback;
+}
+
+function normalizeSlug(value, fallback = '') {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+function isSparseAttentionFamily(modelFamily) {
+  return modelFamily.startsWith('deepseek') || modelFamily.startsWith('glm');
+}
+
+function resolveProviderMode(env = process.env) {
+  const explicit = normalizeSlug(env.THUMBGATE_PROVIDER_MODE || env.THUMBGATE_MODEL_PROVIDER_MODE);
+  if (explicit === 'local' || explicit === 'managed') return explicit;
+  if (env.THUMBGATE_LOCAL_MODEL_FAMILY || env.THUMBGATE_LOCAL_MODEL_SERVER) return 'local';
+  return 'managed';
+}
+
+function resolveServerEngine(env = process.env, providerMode = resolveProviderMode(env)) {
+  const explicit = normalizeSlug(env.THUMBGATE_LOCAL_MODEL_SERVER || env.THUMBGATE_MODEL_SERVER);
+  if (explicit) return explicit;
+  return providerMode === 'local' ? 'generic' : 'api';
+}
+
+function resolveModelFamily(env = process.env) {
+  return normalizeSlug(
+    env.THUMBGATE_LOCAL_MODEL_FAMILY
+      || env.THUMBGATE_MODEL_FAMILY
+      || env.THUMBGATE_LOCAL_MODEL
+      || env.THUMBGATE_MODEL_ID,
+    'unknown',
+  );
+}
+
+function buildBackendLabel(providerMode, modelFamily) {
+  if (providerMode === 'managed') return 'Managed API backend';
+  if (modelFamily.startsWith('deepseek')) return 'Local DeepSeek sparse backend';
+  if (modelFamily.startsWith('glm')) return 'Local GLM sparse backend';
+  return 'Local dense backend';
+}
+
+function detectInferenceBackend(env = process.env) {
+  const providerMode = resolveProviderMode(env);
+  const modelFamily = resolveModelFamily(env);
+  const serverEngine = resolveServerEngine(env, providerMode);
+  const supportsSparseAttention = isSparseAttentionFamily(modelFamily);
+  const indexCacheEligible = providerMode === 'local'
+    && supportsSparseAttention
+    && INDEXCACHE_SERVER_ENGINES.has(serverEngine);
+  const indexCacheEnabled = indexCacheEligible && parseBoolean(env.THUMBGATE_INDEXCACHE_ENABLED, false);
+  const id = providerMode === 'managed'
+    ? 'managed-api'
+    : supportsSparseAttention
+      ? `local-${modelFamily}-sparse`
+      : 'local-dense';
+
+  let rationale = 'Baseline backend with no sparse-attention acceleration.';
+  if (providerMode === 'managed') {
+    rationale = 'Managed API path does not expose sparse-attention kernel controls like IndexCache.';
+  } else if (indexCacheEnabled) {
+    rationale = `Local ${modelFamily} backend is sparse-attention capable and IndexCache-ready on ${serverEngine}.`;
+  } else if (indexCacheEligible) {
+    rationale = `Local ${modelFamily} backend is sparse-attention capable and can use IndexCache on ${serverEngine}.`;
+  } else if (supportsSparseAttention) {
+    rationale = `Local ${modelFamily} backend is sparse-attention capable, but current server engine "${serverEngine}" is not marked IndexCache-ready.`;
+  }
+
+  return {
+    id,
+    label: buildBackendLabel(providerMode, modelFamily),
+    providerMode,
+    modelFamily,
+    serverEngine,
+    supportsSparseAttention,
+    indexCacheEligible,
+    indexCacheEnabled,
+    longContextOptimized: indexCacheEnabled,
+    rationale,
+  };
+}
+
+function isLongContextTask(task = {}) {
+  const contextTokens = Number(task.contextTokens || 0);
+  const tags = Array.isArray(task.tags) ? task.tags.map((tag) => normalizeSlug(tag)) : [];
+  return contextTokens >= 120000
+    || LONG_CONTEXT_TASK_TYPES.has(normalizeSlug(task.type))
+    || tags.some((tag) => LONG_CONTEXT_TAGS.has(tag));
+}
+
+function recommendInferenceBackend(task = {}, env = process.env) {
+  const backend = detectInferenceBackend(env);
+  const privacyRoute = task.privacyRoute || 'frontier';
+  const workloadClass = isLongContextTask(task) ? 'long_context' : 'baseline';
+
+  if (privacyRoute === 'local' && backend.providerMode !== 'local') {
+    return {
+      backend,
+      workloadClass,
+      recommendationClass: 'privacy_local_required',
+      route: 'local',
+      reason: 'privacy-sensitive workload should stay on a local backend before any long-context optimization.',
+    };
+  }
+
+  if (workloadClass === 'long_context' && backend.indexCacheEnabled) {
+    return {
+      backend,
+      workloadClass,
+      recommendationClass: 'indexcache_active',
+      route: backend.providerMode,
+      reason: `current backend ${backend.id} is IndexCache-ready for long-context sparse-attention workloads.`,
+    };
+  }
+
+  if (workloadClass === 'long_context' && backend.indexCacheEligible) {
+    return {
+      backend,
+      workloadClass,
+      recommendationClass: 'indexcache_eligible',
+      route: backend.providerMode,
+      reason: `current backend ${backend.id} is sparse-attention capable; enabling IndexCache is the highest-ROI latency/cost improvement.`,
+    };
+  }
+
+  if (workloadClass === 'long_context') {
+    return {
+      backend,
+      workloadClass,
+      recommendationClass: 'baseline_long_context',
+      route: backend.providerMode,
+      reason: backend.providerMode === 'managed'
+        ? 'managed API path hides sparse-attention kernel controls, so IndexCache-style gains are unavailable here.'
+        : `current local backend ${backend.id} is not yet IndexCache-eligible.`,
+    };
+  }
+
+  return {
+    backend,
+    workloadClass,
+    recommendationClass: 'baseline',
+    route: privacyRoute === 'local' ? 'local' : backend.providerMode,
+    reason: 'baseline workload does not need sparse-attention optimization.',
+  };
+}
+
+function resolveFeedbackDir(explicitDir) {
+  return explicitDir || process.env.THUMBGATE_FEEDBACK_DIR || DEFAULT_FEEDBACK_DIR;
+}
+
+function detectHardware(env = process.env) {
+  const totalMemBytes = parseNumber(env.THUMBGATE_RAM_BYTES_OVERRIDE, os.totalmem());
+  const ramGb = Math.round((totalMemBytes / (1024 ** 3)) * 10) / 10;
+  const cpuCount = Math.max(1, Math.floor(parseNumber(env.THUMBGATE_CPU_COUNT_OVERRIDE, os.cpus().length || 1)));
+  const platform = env.THUMBGATE_PLATFORM_OVERRIDE || process.platform;
+  const arch = env.THUMBGATE_ARCH_OVERRIDE || process.arch;
+  const ci = parseBoolean(env.CI, false);
+  const accelerator = env.THUMBGATE_ACCELERATOR
+    || (platform === 'darwin' && arch === 'arm64' ? 'metal' : 'cpu');
+
+  return {
+    ramGb,
+    cpuCount,
+    platform,
+    arch,
+    accelerator,
+    ci,
+  };
+}
+
+function pickAutoProfile(hardware) {
+  if (hardware.ci || hardware.ramGb < 8 || hardware.cpuCount <= 4) {
+    return EMBEDDING_PROFILES.compact;
+  }
+  if (hardware.ramGb >= 24 && hardware.cpuCount >= 8 && !hardware.ci) {
+    return EMBEDDING_PROFILES.quality;
+  }
+  return EMBEDDING_PROFILES.balanced;
+}
+
+function cloneProfile(profile) {
+  return {
+    id: profile.id,
+    model: profile.model,
+    quantized: profile.quantized,
+    maxChars: profile.maxChars,
+    rationale: profile.rationale,
+  };
+}
+
+function resolveEmbeddingProfile(env = process.env) {
+  const hardware = detectHardware(env);
+  const requestedProfile = String(env.THUMBGATE_MODEL_FIT_PROFILE || 'auto').trim().toLowerCase();
+
+  const baseProfile = requestedProfile !== 'auto' && EMBEDDING_PROFILES[requestedProfile]
+    ? EMBEDDING_PROFILES[requestedProfile]
+    : pickAutoProfile(hardware);
+
+  const profile = cloneProfile(baseProfile);
+  const source = requestedProfile !== 'auto' && EMBEDDING_PROFILES[requestedProfile]
+    ? 'profile_override'
+    : 'auto';
+
+  if (env.THUMBGATE_EMBED_MODEL) {
+    profile.model = String(env.THUMBGATE_EMBED_MODEL).trim();
+  }
+  profile.quantized = parseBoolean(env.THUMBGATE_EMBED_QUANTIZED, profile.quantized);
+  profile.maxChars = Math.max(256, Math.floor(parseNumber(env.THUMBGATE_EMBED_MAX_CHARS, profile.maxChars)));
+
+  const fallback = cloneProfile(EMBEDDING_PROFILES.balanced);
+  fallback.id = 'fallback';
+
+  return {
+    source,
+    hardware,
+    selectedProfile: profile,
+    fallbackProfile: fallback,
+  };
+}
+
+/**
+ * Resolve the LLM model ID for a given workload role.
+ *
+ * Roles: normal, thinking, critique, compaction, vlm
+ * Each role can be overridden via THUMBGATE_MODEL_ROLE_<ROLE> env var.
+ *
+ * @param {string} role - One of the valid model roles
+ * @param {object} [env=process.env]
+ * @returns {{ role: string, model: string, provider: string, envKey: string }}
+ */
+function resolveModelRole(role, env) {
+  const e = env || process.env;
+  const normalized = String(role || '').toLowerCase().trim();
+  if (!MODEL_ROLES[normalized]) {
+    throw new Error(`Unknown model role: '${normalized}'. Valid roles: ${VALID_MODEL_ROLES.join(', ')}`);
+  }
+  const envKey = `THUMBGATE_MODEL_ROLE_${normalized.toUpperCase()}`;
+  const model = (e[envKey] && String(e[envKey]).trim()) || MODEL_ROLES[normalized];
+  return { role: normalized, model, provider: 'gemini', envKey };
+}
+
+function buildModelFitReport(options = {}) {
+  const resolved = options.resolved || resolveEmbeddingProfile(options.env);
+  const selected = resolved.selectedProfile;
+  const fallback = resolved.fallbackProfile;
+  const summary = selected.quantized
+    ? `${selected.id} profile selected with quantized ${selected.model}`
+    : `${selected.id} profile selected with full-precision ${selected.model}`;
+
+  return {
+    generatedAt: new Date().toISOString(),
+    source: resolved.source,
+    hardware: resolved.hardware,
+    selectedProfile: selected,
+    fallbackProfile: fallback,
+    summary,
+  };
+}
+
+function getModelFitReportPath(feedbackDir) {
+  return path.join(resolveFeedbackDir(feedbackDir), 'model-fit-report.json');
+}
+
+function writeModelFitReport(feedbackDir, options = {}) {
+  const report = buildModelFitReport(options);
+  const reportPath = getModelFitReportPath(feedbackDir);
+  fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+  fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+  return { reportPath, report };
+}
+
+module.exports = {
+  DEFAULT_EMBED_MODEL,
+  DEFAULT_FEEDBACK_DIR,
+  EMBEDDING_PROFILES,
+  INDEXCACHE_SERVER_ENGINES,
+  LONG_CONTEXT_TAGS,
+  LONG_CONTEXT_TASK_TYPES,
+  MODEL_ROLES,
+  VALID_MODEL_ROLES,
+  detectHardware,
+  detectInferenceBackend,
+  resolveEmbeddingProfile,
+  resolveModelRole,
+  buildModelFitReport,
+  writeModelFitReport,
+  getModelFitReportPath,
+  isLongContextTask,
+  recommendInferenceBackend,
+  resolveFeedbackDir,
+};
+
+if (require.main === module) {
+  const report = buildModelFitReport();
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+}

package/scripts/markdown-escape.js

@@ -0,0 +1,12 @@
+'use strict';
+
+function escapeMarkdownTableCell(value) {
+  return String(value || '')
+    .replace(/\\/g, '\\\\')
+    .replace(/\|/g, '\\|')
+    .replace(/\r?\n/g, ' ');
+}
+
+module.exports = {
+  escapeMarkdownTableCell,
+};