tribunal-kit 9.2.4 → 9.2.6

package/src/context/ranker.js

@@ -0,0 +1,339 @@
+'use strict';
+
+/**
+ * ranker.js — Deterministic Evidence-Driven Context Ranking Engine
+ * =================================================================
+ * System-1 Capability 2:
+ * Evaluates repository evidence deterministically to rank candidate files
+ * for prompt context selection, ensuring maximum relevant evidence and
+ * minimum unnecessary context.
+ *
+ * Guarantees:
+ * - Stable, deterministic ordering (score DESC, path ASC)
+ * - Zero LLM dependency for ranking
+ * - Critical security boundaries receive mandatory retention
+ * - Configurable token and item budgets
+ * - Explicit before/after measurement metrics
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SECURITY_PATTERNS = [
+  /[\\/](?:auth|security|permissions?|jwt|crypto|secrets?|tokens?|passwords?|sessions?)[\\/.]/i,
+  /[\\/](?:roles?|access-control|rbac|oauth|sso)[\\/.]/i,
+  /[\\/]SECURITY\.md$/i,
+  /[\\/]\.env/i,
+];
+
+const CONFIG_PATTERNS = [
+  /[\\/](?:package\.json|tsconfig\.json|Cargo\.toml|Cargo\.lock|go\.mod|pyproject\.toml)$/i,
+  /[\\/](?:\.eslintrc|\.prettierrc|jest\.config|vitest\.config|webpack\.config|vite\.config)[^\\/]*$/i,
+  /[\\/]Dockerfile/i,
+  /[\\/](?:docker-compose|\.github[\\/]workflows)/i,
+];
+
+const DOC_PATTERNS = [
+  /\.(?:md|markdown|txt|rst|adoc)$/i,
+  /[\\/]docs[\\/]/i,
+];
+
+const TEST_PATTERNS = [
+  /\.(?:test|spec)\.[a-zA-Z0-9]+$/i,
+  /[\\/](?:__tests__|tests?|fixtures?)[\\/]/i,
+];
+
+const ENTRY_PATTERNS = [
+  /[\\/](?:index|main|cli|app|server)\.[a-zA-Z0-9]+$/i,
+  /[\\/]api[\\/]/i,
+];
+
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function estimateTokens(textOrBytes) {
+  if (typeof textOrBytes === 'number') {
+    return Math.max(1, Math.ceil(textOrBytes / 4));
+  }
+  if (typeof textOrBytes === 'string') {
+    return Math.max(1, Math.ceil(textOrBytes.length / 4));
+  }
+  return 1;
+}
+
+/**
+ * Extract direct import / require targets from code text
+ */
+function extractImports(code) {
+  const imports = new Set();
+  const importRegex = /(?:import\s+(?:[\w*\s{},]*\s+from\s+)?['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+  let match;
+  while ((match = importRegex.exec(code)) !== null) {
+    const target = match[1] || match[2];
+    if (target && (target.startsWith('.') || target.startsWith('/'))) {
+      imports.add(target);
+    }
+  }
+  return imports;
+}
+
+/**
+ * Check if candidateFile is imported by targetFile or vice versa
+ */
+function checkImportRelation(candidateRel, targetRel, fileContents) {
+  const targetContent = fileContents.get(targetRel) || '';
+  const candidateContent = fileContents.get(candidateRel) || '';
+
+  const targetBasename = path.basename(targetRel, path.extname(targetRel));
+  const candidateBasename = path.basename(candidateRel, path.extname(candidateRel));
+
+  let isDirectDependency = false;
+  let isDirectImporter = false;
+
+  // Check target -> candidate
+  if (targetContent) {
+    const targetImports = extractImports(targetContent);
+    for (const imp of targetImports) {
+      if (imp.includes(candidateBasename) || imp.endsWith(candidateBasename)) {
+        isDirectDependency = true;
+        break;
+      }
+    }
+  }
+
+  // Check candidate -> target
+  if (candidateContent) {
+    const candidateImports = extractImports(candidateContent);
+    for (const imp of candidateImports) {
+      if (imp.includes(targetBasename) || imp.endsWith(targetBasename)) {
+        isDirectImporter = true;
+        break;
+      }
+    }
+  }
+
+  return { isDirectDependency, isDirectImporter };
+}
+
+/**
+ * Deterministic Context Ranking Engine
+ * @param {Object} options
+ * @param {string} [options.repoRoot] - Repository root directory
+ * @param {string[]} [options.targetFiles] - Array of directly modified files
+ * @param {string[]} [options.candidateFiles] - Array of candidate files to rank
+ * @param {number} [options.maxTokens] - Maximum token budget for ranking
+ * @param {number} [options.maxItems] - Maximum item count for ranking
+ * @returns {Object} Ranking payload with scored items and measurement metrics
+ */
+function rankContext(options = {}) {
+  const repoRoot = options.repoRoot ? path.resolve(options.repoRoot) : process.cwd();
+  const rawTargetFiles = options.targetFiles || [];
+  const targetFiles = (Array.isArray(rawTargetFiles) ? rawTargetFiles : [rawTargetFiles])
+    .map(normalizePath)
+    .filter(Boolean);
+
+  let rawCandidates = options.candidateFiles || [];
+  if (!Array.isArray(rawCandidates)) rawCandidates = [rawCandidates];
+
+  // If candidates not provided, union of targetFiles
+  const candidateSet = new Set(rawCandidates.map(normalizePath).filter(Boolean));
+  for (const tf of targetFiles) {
+    candidateSet.add(tf);
+  }
+
+  const allCandidatePaths = Array.from(candidateSet);
+
+  // Pre-load content for import analysis if files exist on disk
+  const fileContents = new Map();
+  const fileStats = new Map();
+
+  for (const relPath of allCandidatePaths) {
+    const absPath = path.resolve(repoRoot, relPath);
+    if (fs.existsSync(absPath)) {
+      try {
+        const stat = fs.statSync(absPath);
+        if (stat.isFile()) {
+          fileStats.set(relPath, stat);
+          // Only read if reasonably sized (< 2MB)
+          if (stat.size < 2 * 1024 * 1024) {
+            fileContents.set(relPath, fs.readFileSync(absPath, 'utf8'));
+          }
+        }
+      } catch (_) {}
+    }
+  }
+
+  const scoredItems = [];
+  let totalTokensBefore = 0;
+
+  for (const relPath of allCandidatePaths) {
+    const norm = normalizePath(relPath);
+    const reasons = [];
+    let score = 0.05; // Base baseline
+    let isMandatory = false;
+
+    const stat = fileStats.get(norm);
+    const content = fileContents.get(norm);
+    const sizeBytes = stat ? stat.size : 100;
+    const estimatedTokens = content ? estimateTokens(content) : estimateTokens(sizeBytes);
+    totalTokensBefore += estimatedTokens;
+
+    const isDirectlyModified = targetFiles.includes(norm);
+    const isRootSecurityBoundary = /[\\/]SECURITY\.md$/i.test('/' + norm) || /[\\/]\.env/i.test('/' + norm);
+    const isSecurityDomain = SECURITY_PATTERNS.some(pat => pat.test('/' + norm));
+    const isConfig = CONFIG_PATTERNS.some(pat => pat.test('/' + norm));
+    const isDoc = DOC_PATTERNS.some(pat => pat.test('/' + norm));
+    const isTest = TEST_PATTERNS.some(pat => pat.test('/' + norm));
+    const isEntrypoint = ENTRY_PATTERNS.some(pat => pat.test('/' + norm));
+
+    // Signal 1: Directly modified file (1.00, mandatory)
+    if (isDirectlyModified) {
+      score = Math.max(score, 1.00);
+      reasons.push('directly modified');
+      isMandatory = true;
+    }
+
+    // Signal 2: Security boundary (0.95, mandatory for root policy; 0.90 for security domain)
+    if (isRootSecurityBoundary) {
+      score = Math.max(score, 0.95);
+      reasons.push('security boundary');
+      isMandatory = true;
+    } else if (isSecurityDomain && !isDirectlyModified) {
+      score = Math.max(score, 0.90);
+      reasons.push('security domain module');
+    }
+
+    // Signal 3 & 4: Import relationships with target files (0.85 importer, 0.80 dependency)
+    for (const tf of targetFiles) {
+      if (tf === norm) continue;
+      const { isDirectDependency, isDirectImporter } = checkImportRelation(norm, tf, fileContents);
+      if (isDirectImporter) {
+        score = Math.max(score, 0.85);
+        reasons.push(`direct importer of ${path.basename(tf)}`);
+      }
+      if (isDirectDependency) {
+        score = Math.max(score, 0.80);
+        reasons.push(`direct dependency of ${path.basename(tf)}`);
+      }
+    }
+
+    // Signal 5: Test covering changed behavior (0.75 covering test; 0.20 unrelated test)
+    if (isTest) {
+      const targetBaseNames = targetFiles.map(tf => path.basename(tf).replace(/\.[^.]+$/, ''));
+      const coversTarget = targetBaseNames.some(tb => norm.includes(tb));
+      if (coversTarget) {
+        score = Math.max(score, 0.75);
+        reasons.push('test covering changed behavior');
+      } else {
+        score = Math.max(score, 0.20);
+        reasons.push('unrelated test suite');
+      }
+    }
+
+    // Signal 6: Configuration controlling behavior (0.70)
+    if (isConfig) {
+      score = Math.max(score, 0.70);
+      reasons.push('configuration controlling behavior');
+    }
+
+    // Signal 7: Public API entry point (0.65)
+    if (isEntrypoint && !isDirectlyModified) {
+      score = Math.max(score, 0.65);
+      reasons.push('public API surface');
+    }
+
+    // Signal 8: Architectural parent / sibling directory (0.50)
+    if (!isDirectlyModified && targetFiles.some(tf => path.dirname(tf) === path.dirname(norm))) {
+      score = Math.max(score, 0.50);
+      reasons.push('architectural sibling/parent');
+    }
+
+    // Signal 9: Documentation (0.25)
+    if (isDoc && !isRootSecurityBoundary && !isSecurityDomain) {
+      score = Math.max(score, 0.25);
+      reasons.push('documentation');
+    }
+
+    // Fallback: If no reasons matched, mark as unrelated (0.05 baseline)
+    if (reasons.length === 0) {
+      reasons.push('unrelated repository content');
+    }
+
+    const finalScore = parseFloat(Math.min(1.0, Math.max(0.05, score)).toFixed(2));
+
+    scoredItems.push({
+      path: norm,
+      score: finalScore,
+      reasons,
+      is_mandatory: isMandatory,
+      size_bytes: sizeBytes,
+      estimated_tokens: estimatedTokens,
+    });
+  }
+
+  // Deterministic stable sort: score DESCENDING, path ASCENDING
+  scoredItems.sort((a, b) => {
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    return a.path.localeCompare(b.path);
+  });
+
+  // Apply budget constraints (maxTokens, maxItems)
+  const maxTokens = typeof options.maxTokens === 'number' && options.maxTokens > 0 ? options.maxTokens : Infinity;
+  const maxItems = typeof options.maxItems === 'number' && options.maxItems > 0 ? options.maxItems : Infinity;
+
+  const rankedItems = [];
+  const truncatedItems = [];
+  let currentTokens = 0;
+
+  // Step 1: Retain all mandatory items first
+  const mandatoryItems = scoredItems.filter(item => item.is_mandatory);
+  const optionalItems = scoredItems.filter(item => !item.is_mandatory);
+
+  for (const item of mandatoryItems) {
+    rankedItems.push(item);
+    currentTokens += item.estimated_tokens;
+  }
+
+  // Step 2: Include optional items up to the budget limits
+  for (const item of optionalItems) {
+    const wouldExceedTokens = (currentTokens + item.estimated_tokens) > maxTokens;
+    const wouldExceedItems = (rankedItems.length + 1) > maxItems;
+
+    if (!wouldExceedTokens && !wouldExceedItems) {
+      rankedItems.push(item);
+      currentTokens += item.estimated_tokens;
+    } else {
+      truncatedItems.push(item);
+    }
+  }
+
+  // Re-sort rankedItems so display follows deterministic score order
+  rankedItems.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.path.localeCompare(b.path);
+  });
+
+  const totalTokensAfter = rankedItems.reduce((acc, it) => acc + it.estimated_tokens, 0);
+  const criticalRetained = rankedItems.filter(it => it.is_mandatory).length;
+
+  return {
+    ranked_items: rankedItems,
+    truncated_items: truncatedItems,
+    metrics: {
+      context_items_before: allCandidatePaths.length,
+      context_items_after: rankedItems.length,
+      estimated_tokens_before: totalTokensBefore,
+      estimated_tokens_after: totalTokensAfter,
+      critical_evidence_retained: criticalRetained,
+    },
+  };
+}
+
+module.exports = {
+  rankContext,
+  normalizePath,
+  estimateTokens,
+};

package/{dist → src}/esm/index.mjs

@@ -2,7 +2,7 @@
  * tribunal-kit ESM entry point.
  *
  * This thin wrapper re-exports the CJS modules as ESM using createRequire.
- * The actual implementation remains in CommonJS (dist/cli.js) to avoid
+ * The actual implementation remains in CommonJS (src/cli.js) to avoid
  * a full migration while providing ESM compatibility for modern bundlers.
  */
 
@@ -40,7 +40,9 @@ function loadCommand(modulePath, functionName, ...args) {
     const mod = require(modulePath);
     return mod[functionName](...args);
   } catch (err) {
-    throw new Error(`Tribunal ESM wrapper failed to load command '${functionName}' from '${modulePath}': ${err.message}`);
+    throw new Error(
+      `Tribunal ESM wrapper failed to load command '${functionName}' from '${modulePath}': ${err.message}`,
+    );
   }
 }
 

package/src/evolution/engine.js

@@ -0,0 +1,295 @@
+'use strict';
+
+/**
+ * evolution/engine.js — Controlled Self-Evolution Engine for Tribunal Kit
+ * =======================================================================
+ * System-1 Capability 4:
+ * Governs the proposal-driven evolution of reviewer routing, context weights,
+ * heuristics, skill idioms, and regression fixtures while strictly enforcing:
+ *
+ * 1. The Human Gate: No evolution can silently deploy without human approval.
+ * 2. Trust Boundaries: Protected security boundaries, execution policies, and
+ *    package integrity validation can NEVER automatically evolve.
+ * 3. Anti-Self-Poisoning: Follows strict evidence hierarchy:
+ *    VERIFIED_TEST_RESULT > DETERMINISTIC_TELEMETRY > REPRODUCIBLE_PATTERN > REVIEWER_CLAIM
+ *    Proposals based solely on unverified LLM claims are rejected.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const ALLOWED_TARGETS = new Set([
+  'reviewer-routing',
+  'context-weights',
+  'skill-instructions',
+  'reviewer-selection',
+  'deterministic-heuristics',
+  'known-failure-patterns',
+  'workflow-guidance',
+  'regression-fixtures',
+]);
+
+const FORBIDDEN_TARGETS = new Set([
+  'security-boundaries',
+  'shell-execution-policy',
+  'package-integrity',
+  'dependency-pinning',
+  'human-gate',
+  'system1-trust-boundary',
+  'production-security',
+  'arbitrary-executable-code',
+]);
+
+const EVIDENCE_HIERARCHY = {
+  VERIFIED_TEST_RESULT: 4,
+  DETERMINISTIC_TELEMETRY: 3,
+  REPRODUCIBLE_PATTERN: 2,
+  REVIEWER_CLAIM: 1,
+};
+
+/**
+ * Creates and formats a new Evolution Proposal.
+ */
+function createEvolutionProposal({
+  target,
+  currentBehavior,
+  observedEvidence,
+  proposedChange,
+  expectedEffect,
+  risk = 'MEDIUM',
+  testsRequired = [],
+  regressionRequirements = [],
+  evidenceType = 'DETERMINISTIC_TELEMETRY',
+  proposalId = null,
+}) {
+  const id = proposalId || `EVO-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+
+  const proposal = {
+    proposal_id: id,
+    target,
+    current_behavior: currentBehavior,
+    observed_evidence: observedEvidence,
+    proposed_change: proposedChange,
+    expected_effect: expectedEffect,
+    risk: ['LOW', 'MEDIUM', 'HIGH'].includes(String(risk).toUpperCase())
+      ? String(risk).toUpperCase()
+      : 'MEDIUM',
+    tests_required: Array.isArray(testsRequired) ? testsRequired : [testsRequired],
+    regression_requirements: Array.isArray(regressionRequirements)
+      ? regressionRequirements
+      : [regressionRequirements],
+    evidence_type: EVIDENCE_HIERARCHY[evidenceType] ? evidenceType : 'REVIEWER_CLAIM',
+    evidence_weight: EVIDENCE_HIERARCHY[evidenceType] || 1,
+    status: 'PROPOSED',
+    created_at: new Date().toISOString(),
+    approval: null,
+  };
+
+  return proposal;
+}
+
+/**
+ * Validates an evolution proposal against Anti-Self-Poisoning & Security Rules.
+ */
+function validateEvolutionProposal(proposal) {
+  if (!proposal || typeof proposal !== 'object') {
+    return { valid: false, reason: 'Proposal must be an object.' };
+  }
+
+  // 1. Check required fields
+  const requiredFields = [
+    'proposal_id',
+    'target',
+    'current_behavior',
+    'observed_evidence',
+    'proposed_change',
+    'expected_effect',
+    'risk',
+    'tests_required',
+    'regression_requirements',
+  ];
+
+  for (const field of requiredFields) {
+    if (!proposal[field] || (Array.isArray(proposal[field]) && proposal[field].length === 0)) {
+      return {
+        valid: false,
+        reason: `Missing required proposal field: "${field}". Every proposal must be backed by evidence.`,
+      };
+    }
+  }
+
+  // 2. Security boundary enforcement: Forbidden targets cannot evolve automatically
+  if (FORBIDDEN_TARGETS.has(proposal.target)) {
+    return {
+      valid: false,
+      reason: `Target "${proposal.target}" is a protected security boundary. Automatic evolution of security boundaries, shell policies, and package integrity is strictly forbidden.`,
+    };
+  }
+
+  // 3. Allowed target check
+  if (!ALLOWED_TARGETS.has(proposal.target)) {
+    return {
+      valid: false,
+      reason: `Target "${proposal.target}" is not an allowed evolution target. Allowed: ${Array.from(ALLOWED_TARGETS).join(', ')}`,
+    };
+  }
+
+  // 4. Anti-Self-Poisoning Rule: Reject proposals backed solely by unverified claims
+  const evidenceType = proposal.evidence_type || 'REVIEWER_CLAIM';
+  const evidenceWeight = EVIDENCE_HIERARCHY[evidenceType] || 0;
+
+  if (evidenceWeight <= EVIDENCE_HIERARCHY.REVIEWER_CLAIM) {
+    return {
+      valid: false,
+      reason: `Anti-Self-Poisoning violation: Proposal relies solely on "${evidenceType}". Proposals must be backed by reproducible execution patterns, deterministic telemetry, or verified test results.`,
+    };
+  }
+
+  // 5. Evidence content check
+  if (
+    typeof proposal.observed_evidence !== 'string' ||
+    proposal.observed_evidence.trim().length < 10
+  ) {
+    return {
+      valid: false,
+      reason: 'Observed evidence is too short or vacuous. Measurable, concrete evidence is required.',
+    };
+  }
+
+  return { valid: true, reason: 'Proposal meets all verification and safety criteria.' };
+}
+
+/**
+ * Storage helpers for proposal persistence.
+ */
+function getProposalsDir(agentDir = path.join(process.cwd(), '.agent')) {
+  return path.join(agentDir, 'evolution', 'proposals');
+}
+
+function findDuplicateProposal(proposal, agentDir) {
+  const existingProposals = loadEvolutionProposals(agentDir);
+  return (
+    existingProposals.find(
+      p =>
+        p.target === proposal.target &&
+        (p.proposed_change === proposal.proposed_change ||
+          JSON.stringify(p.proposed_change) === JSON.stringify(proposal.proposed_change)) &&
+        p.status !== 'REJECTED',
+    ) || null
+  );
+}
+
+function saveEvolutionProposal(proposal, agentDir, options = {}) {
+  const validation = validateEvolutionProposal(proposal);
+  if (!validation.valid) {
+    throw new Error(`Cannot save invalid evolution proposal: ${validation.reason}`);
+  }
+
+  const dir = getProposalsDir(agentDir);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  // Phase 5 Case D: Duplicate proposal detection
+  const duplicate = findDuplicateProposal(proposal, agentDir);
+  if (duplicate) {
+    if (options.throwOnDuplicate !== false) {
+      const err = new Error(
+        `Duplicate evolution proposal detected: matches existing proposal ${duplicate.proposal_id}`,
+      );
+      err.code = 'DUPLICATE_PROPOSAL';
+      err.duplicate = true;
+      err.existing_proposal_id = duplicate.proposal_id;
+      throw err;
+    }
+    return {
+      saved: false,
+      duplicate: true,
+      existing_proposal_id: duplicate.proposal_id,
+      filePath: path.join(dir, `${duplicate.proposal_id}.json`),
+      message: `Duplicate proposal detected: matches existing proposal ${duplicate.proposal_id}`,
+    };
+  }
+
+  const filePath = path.join(dir, `${proposal.proposal_id}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(proposal, null, 2), 'utf8');
+  return filePath;
+}
+
+function loadEvolutionProposals(agentDir) {
+  const dir = getProposalsDir(agentDir);
+  if (!fs.existsSync(dir)) return [];
+
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+  const proposals = [];
+
+  for (const f of files) {
+    try {
+      const p = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'));
+      proposals.push(p);
+    } catch (_) {}
+  }
+
+  return proposals;
+}
+
+/**
+ * Human Gate: Explicitly approve an evolution proposal.
+ */
+function approveEvolutionProposal(proposalId, approverName, agentDir) {
+  if (!approverName || typeof approverName !== 'string') {
+    throw new Error('Human approval requires an explicit approver name/signature.');
+  }
+
+  const dir = getProposalsDir(agentDir);
+  const filePath = path.join(dir, `${proposalId}.json`);
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Evolution proposal not found: ${proposalId}`);
+  }
+
+  const proposal = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  proposal.status = 'APPROVED';
+  proposal.approval = {
+    approved_by: approverName,
+    approved_at: new Date().toISOString(),
+    human_gate_cleared: true,
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(proposal, null, 2), 'utf8');
+  return proposal;
+}
+
+/**
+ * Reject an evolution proposal.
+ */
+function rejectEvolutionProposal(proposalId, reason, agentDir) {
+  const dir = getProposalsDir(agentDir);
+  const filePath = path.join(dir, `${proposalId}.json`);
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Evolution proposal not found: ${proposalId}`);
+  }
+
+  const proposal = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  proposal.status = 'REJECTED';
+  proposal.rejection = {
+    reason: reason || 'Rejected by developer',
+    rejected_at: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(proposal, null, 2), 'utf8');
+  return proposal;
+}
+
+module.exports = {
+  createEvolutionProposal,
+  validateEvolutionProposal,
+  saveEvolutionProposal,
+  findDuplicateProposal,
+  loadEvolutionProposals,
+  approveEvolutionProposal,
+  rejectEvolutionProposal,
+  ALLOWED_TARGETS,
+  FORBIDDEN_TARGETS,
+  EVIDENCE_HIERARCHY,
+};

package/src/mcp/server.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Compatibility entry point for the historical src/mcp/server.js path.
+ * bin/mcp-server.js is the single canonical MCP implementation.
+ */
+module.exports = require('../../bin/mcp-server.js');