@vitronai/themis 0.1.0-beta.4 → 0.1.1

package/src/contracts.js

@@ -0,0 +1,330 @@
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+
+const CONTRACT_ARTIFACT_DIR = path.join('.themis', 'contracts');
+
+function createContractHarness(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const getCurrentTest = typeof options.getCurrentTest === 'function'
+    ? options.getCurrentTest
+    : () => null;
+  const updateContracts = Boolean(options.updateContracts);
+  const events = [];
+
+  function captureContract(name, value, contractOptions = {}) {
+    const currentTest = getCurrentTest();
+    if (!currentTest || !currentTest.fullName) {
+      throw new Error('captureContract(...) is only available while a Themis test is running');
+    }
+
+    const contractName = String(name || '').trim();
+    if (!contractName) {
+      throw new Error('captureContract(...) requires a non-empty contract name');
+    }
+
+    const normalizedValue = applyContractOptions(value, contractOptions);
+    const contractKey = buildContractKey(currentTest, contractName);
+    const relativeFile = contractOptions.file
+      ? normalizeRelativeContractPath(contractOptions.file)
+      : path.join(CONTRACT_ARTIFACT_DIR, `${contractKey}.json`).split(path.sep).join('/');
+    const absoluteFile = path.join(cwd, relativeFile);
+    const previous = readExistingContract(absoluteFile);
+    const diff = previous.exists
+      ? createContractDiff(previous.value, normalizedValue)
+      : createCreatedContractDiff(normalizedValue);
+
+    let status = 'unchanged';
+    if (!previous.exists) {
+      status = 'created';
+      ensureContractDirectory(absoluteFile);
+      fs.writeFileSync(absoluteFile, `${JSON.stringify(normalizedValue, null, 2)}\n`, 'utf8');
+    } else if (!diff.equal && updateContracts) {
+      status = 'updated';
+      ensureContractDirectory(absoluteFile);
+      fs.writeFileSync(absoluteFile, `${JSON.stringify(normalizedValue, null, 2)}\n`, 'utf8');
+    } else if (!diff.equal) {
+      status = 'drifted';
+    }
+
+    const event = {
+      key: contractKey,
+      name: contractName,
+      status,
+      contractFile: relativeFile,
+      file: currentTest.file,
+      testName: currentTest.name,
+      fullName: currentTest.fullName,
+      updateCommand: `npx themis test --update-contracts --match ${JSON.stringify(currentTest.fullName)}`,
+      diff
+    };
+    events.push(event);
+
+    if (status === 'drifted') {
+      throw new Error(
+        `Contract "${contractName}" drifted for ${currentTest.fullName}. ` +
+        `Review ${relativeFile} and rerun with --update-contracts to accept the new contract.\n` +
+        formatContractDiff(diff)
+      );
+    }
+
+    return normalizedValue;
+  }
+
+  return {
+    captureContract,
+    getEvents() {
+      return events.map((event) => JSON.parse(JSON.stringify(event)));
+    }
+  };
+}
+
+function normalizeContractValue(value) {
+  if (value === null || typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean') {
+    return value;
+  }
+  if (value === undefined) {
+    return '[undefined]';
+  }
+  if (typeof value === 'bigint') {
+    return `${value}n`;
+  }
+  if (typeof value === 'function') {
+    return `[Function ${value.name || 'anonymous'}]`;
+  }
+  if (typeof value === 'symbol') {
+    return String(value);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Buffer.isBuffer(value)) {
+    return {
+      type: 'Buffer',
+      data: value.toString('base64')
+    };
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeContractValue(entry));
+  }
+  if (value instanceof Map) {
+    return [...value.entries()]
+      .map(([key, entryValue]) => [normalizeContractValue(key), normalizeContractValue(entryValue)])
+      .sort(compareContractEntries);
+  }
+  if (value instanceof Set) {
+    return [...value.values()]
+      .map((entry) => normalizeContractValue(entry))
+      .sort(compareNormalizedValues);
+  }
+  if (value && typeof value === 'object') {
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+      normalized[key] = normalizeContractValue(value[key]);
+    }
+    return normalized;
+  }
+  return String(value);
+}
+
+function applyContractOptions(value, contractOptions = {}) {
+  let nextValue = typeof contractOptions.normalize === 'function'
+    ? contractOptions.normalize(value)
+    : value;
+
+  nextValue = normalizeContractValue(nextValue);
+
+  if (Array.isArray(contractOptions.maskPaths) && contractOptions.maskPaths.length > 0) {
+    nextValue = maskContractPaths(nextValue, contractOptions.maskPaths);
+  }
+
+  if (contractOptions.sortArrays) {
+    nextValue = sortNormalizedArrays(nextValue);
+  }
+
+  return nextValue;
+}
+
+function compareContractEntries(left, right) {
+  return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+
+function compareNormalizedValues(left, right) {
+  return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+
+function normalizeRelativeContractPath(filePath) {
+  const normalized = String(filePath || '').split(path.sep).join('/');
+  if (!normalized.startsWith('.themis/')) {
+    return path.join(CONTRACT_ARTIFACT_DIR, normalized).split(path.sep).join('/');
+  }
+  return normalized;
+}
+
+function buildContractKey(test, name) {
+  const parts = [test.file, test.fullName, name]
+    .filter(Boolean)
+    .map((part) => String(part).toLowerCase())
+    .join(' ');
+  return slugify(parts);
+}
+
+function slugify(value) {
+  const slug = String(value || '')
+    .replace(/[^a-zA-Z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-{2,}/g, '-')
+    .toLowerCase();
+  return slug || 'contract';
+}
+
+function ensureContractDirectory(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function readExistingContract(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {
+      exists: false,
+      value: null
+    };
+  }
+
+  const raw = fs.readFileSync(filePath, 'utf8');
+  try {
+    return {
+      exists: true,
+      value: JSON.parse(raw)
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse existing contract at ${filePath}: ${String(error.message || error)}`);
+  }
+}
+
+function createCreatedContractDiff(nextValue) {
+  const flat = flattenContractValue(nextValue);
+  return {
+    equal: false,
+    added: flat.slice(0, 12).map((entry) => ({ path: entry.path, after: entry.value })),
+    removed: [],
+    changed: [],
+    unchangedCount: 0
+  };
+}
+
+function createContractDiff(previousValue, nextValue) {
+  const previousFlat = flattenContractValue(previousValue);
+  const nextFlat = flattenContractValue(nextValue);
+  const previousMap = new Map(previousFlat.map((entry) => [entry.path, entry.value]));
+  const nextMap = new Map(nextFlat.map((entry) => [entry.path, entry.value]));
+  const allPaths = [...new Set([...previousMap.keys(), ...nextMap.keys()])].sort();
+  const added = [];
+  const removed = [];
+  const changed = [];
+  let unchangedCount = 0;
+
+  for (const entryPath of allPaths) {
+    const hasPrevious = previousMap.has(entryPath);
+    const hasNext = nextMap.has(entryPath);
+    if (!hasPrevious && hasNext) {
+      added.push({ path: entryPath, after: nextMap.get(entryPath) });
+      continue;
+    }
+    if (hasPrevious && !hasNext) {
+      removed.push({ path: entryPath, before: previousMap.get(entryPath) });
+      continue;
+    }
+    const before = previousMap.get(entryPath);
+    const after = nextMap.get(entryPath);
+    if (util.isDeepStrictEqual(before, after)) {
+      unchangedCount += 1;
+      continue;
+    }
+    changed.push({ path: entryPath, before, after });
+  }
+
+  return {
+    equal: added.length === 0 && removed.length === 0 && changed.length === 0,
+    added: added.slice(0, 12),
+    removed: removed.slice(0, 12),
+    changed: changed.slice(0, 12),
+    unchangedCount
+  };
+}
+
+function flattenContractValue(value, currentPath = '$') {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [{ path: currentPath, value: [] }];
+    }
+    return value.flatMap((entry, index) => flattenContractValue(entry, `${currentPath}[${index}]`));
+  }
+  if (value && typeof value === 'object') {
+    const keys = Object.keys(value);
+    if (keys.length === 0) {
+      return [{ path: currentPath, value: {} }];
+    }
+    return keys.flatMap((key) => flattenContractValue(value[key], `${currentPath}.${key}`));
+  }
+  return [{ path: currentPath, value }];
+}
+
+function formatContractDiff(diff) {
+  const lines = [];
+  for (const entry of diff.changed.slice(0, 4)) {
+    lines.push(`changed ${entry.path}: ${formatValue(entry.before)} -> ${formatValue(entry.after)}`);
+  }
+  for (const entry of diff.added.slice(0, 4)) {
+    lines.push(`added ${entry.path}: ${formatValue(entry.after)}`);
+  }
+  for (const entry of diff.removed.slice(0, 4)) {
+    lines.push(`removed ${entry.path}: ${formatValue(entry.before)}`);
+  }
+  return lines.join('\n');
+}
+
+function maskContractPaths(value, maskPaths) {
+  const targets = new Set(maskPaths.map((entry) => String(entry)));
+  return visitContractValue(value, '$', (currentValue, currentPath) => {
+    if (targets.has(currentPath)) {
+      return '[masked]';
+    }
+    return currentValue;
+  });
+}
+
+function sortNormalizedArrays(value) {
+  return visitContractValue(value, '$', (currentValue) => {
+    if (!Array.isArray(currentValue)) {
+      return currentValue;
+    }
+    return [...currentValue].sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+  });
+}
+
+function visitContractValue(value, currentPath, visitor) {
+  if (Array.isArray(value)) {
+    const mapped = value.map((entry, index) => visitContractValue(entry, `${currentPath}[${index}]`, visitor));
+    return visitor(mapped, currentPath);
+  }
+  if (value && typeof value === 'object') {
+    const mapped = {};
+    for (const key of Object.keys(value)) {
+      mapped[key] = visitContractValue(value[key], `${currentPath}.${key}`, visitor);
+    }
+    return visitor(mapped, currentPath);
+  }
+  return visitor(value, currentPath);
+}
+
+function formatValue(value) {
+  return util.inspect(value, { depth: 4, colors: false, maxArrayLength: 10 });
+}
+
+module.exports = {
+  CONTRACT_ARTIFACT_DIR,
+  createContractHarness,
+  createContractDiff,
+  formatContractDiff,
+  normalizeContractValue
+};

package/src/migrate.js

@@ -60,7 +60,10 @@ function runMigrate(cwd, framework, options = {}) {
   const rewriteSummary = options.rewriteImports
     ? rewriteMigrationImports(projectRoot, scan.matches, compatPath)
     : { rewrittenFiles: [], rewrittenImports: 0 };
-  const report = buildMigrationReport(projectRoot, source, scan.matches, rewriteSummary);
+  const conversionSummary = options.convert
+    ? convertMigrationFiles(projectRoot, scan.matches)
+    : { convertedFiles: [], convertedAssertions: 0, removedImports: 0 };
+  const report = buildMigrationReport(projectRoot, source, scan.matches, rewriteSummary, conversionSummary);
   fs.mkdirSync(path.dirname(reportPath), { recursive: true });
   fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
 
@@ -74,7 +77,9 @@ function runMigrate(cwd, framework, options = {}) {
     reportPath,
     report,
     rewriteImports: Boolean(options.rewriteImports),
-    rewrittenFiles: rewriteSummary.rewrittenFiles
+    rewrittenFiles: rewriteSummary.rewrittenFiles,
+    convert: Boolean(options.convert),
+    convertedFiles: conversionSummary.convertedFiles
   };
 }
 
@@ -155,7 +160,13 @@ function scanMigrationFiles(projectRoot) {
   };
 }
 
-function buildMigrationReport(projectRoot, source, matches, rewriteSummary = { rewrittenFiles: [], rewrittenImports: 0 }) {
+function buildMigrationReport(
+  projectRoot,
+  source,
+  matches,
+  rewriteSummary = { rewrittenFiles: [], rewrittenImports: 0 },
+  conversionSummary = { convertedFiles: [], convertedAssertions: 0, removedImports: 0 }
+) {
   return {
     schema: 'themis.migration.report.v1',
     source,
@@ -166,7 +177,10 @@ function buildMigrationReport(projectRoot, source, matches, rewriteSummary = { r
       vitest: matches.filter((entry) => entry.imports.includes('vitest')).length,
       testingLibraryReact: matches.filter((entry) => entry.imports.includes('@testing-library/react')).length,
       rewrittenFiles: Array.isArray(rewriteSummary.rewrittenFiles) ? rewriteSummary.rewrittenFiles.length : 0,
-      rewrittenImports: Number(rewriteSummary.rewrittenImports || 0)
+      rewrittenImports: Number(rewriteSummary.rewrittenImports || 0),
+      convertedFiles: Array.isArray(conversionSummary.convertedFiles) ? conversionSummary.convertedFiles.length : 0,
+      convertedAssertions: Number(conversionSummary.convertedAssertions || 0),
+      removedImports: Number(conversionSummary.removedImports || 0)
     },
     files: matches,
     nextActions: [
@@ -176,10 +190,96 @@ function buildMigrationReport(projectRoot, source, matches, rewriteSummary = { r
     ],
     rewrites: Array.isArray(rewriteSummary.rewrittenFiles)
       ? rewriteSummary.rewrittenFiles
+      : [],
+    conversions: Array.isArray(conversionSummary.convertedFiles)
+      ? conversionSummary.convertedFiles
       : []
   };
 }
 
+function convertMigrationFiles(projectRoot, matches) {
+  const convertedFiles = [];
+  let convertedAssertions = 0;
+  let removedImports = 0;
+
+  for (const match of matches) {
+    const absoluteFile = path.join(projectRoot, match.file);
+    const original = fs.readFileSync(absoluteFile, 'utf8');
+    const converted = convertMigrationSourceText(original);
+    if (converted.source !== original) {
+      fs.writeFileSync(absoluteFile, converted.source, 'utf8');
+      convertedFiles.push(match.file);
+      convertedAssertions += converted.convertedAssertions;
+      removedImports += converted.removedImports;
+    }
+  }
+
+  return {
+    convertedFiles,
+    convertedAssertions,
+    removedImports
+  };
+}
+
+function convertMigrationSourceText(sourceText) {
+  let source = sourceText;
+  let convertedAssertions = 0;
+  let removedImports = 0;
+
+  source = source.replace(
+    /^\s*import\s+\{[^}]*\}\s+from\s+['"]@jest\/globals['"];\s*\n?/gm,
+    () => {
+      removedImports += 1;
+      return '';
+    }
+  );
+  source = source.replace(
+    /^\s*import\s+\{[^}]*\}\s+from\s+['"]vitest['"];\s*\n?/gm,
+    () => {
+      removedImports += 1;
+      return '';
+    }
+  );
+  source = source.replace(
+    /^\s*import\s+\{[^}]*\}\s+from\s+['"]@testing-library\/react['"];\s*\n?/gm,
+    () => {
+      removedImports += 1;
+      return '';
+    }
+  );
+
+  const replacements = [
+    { pattern: /\bit\s*\(/g, replacement: 'test(' },
+    { pattern: /\btest\.only\s*\(/g, replacement: 'test(' },
+    { pattern: /\bit\.only\s*\(/g, replacement: 'test(' },
+    { pattern: /\btest\.skip\s*\(/g, replacement: 'test.skip(' },
+    { pattern: /\bit\.skip\s*\(/g, replacement: 'test.skip(' },
+    { pattern: /\.toStrictEqual\s*\(/g, replacement: '.toEqual(' },
+    { pattern: /\.toContainEqual\s*\(/g, replacement: '.toContain(' },
+    { pattern: /\.toBeCalledTimes\s*\(/g, replacement: '.toHaveBeenCalledTimes(' },
+    { pattern: /\.toBeCalledWith\s*\(/g, replacement: '.toHaveBeenCalledWith(' },
+    { pattern: /\.toBeCalled\s*\(/g, replacement: '.toHaveBeenCalled(' },
+    { pattern: /\.lastCalledWith\s*\(/g, replacement: '.toHaveBeenCalledWith(' },
+    { pattern: /\.toBeTruthy\s*\(\s*\)/g, replacement: '.toBeTruthy()' },
+    { pattern: /\.toBeFalsy\s*\(\s*\)/g, replacement: '.toBeFalsy()' }
+  ];
+
+  for (const entry of replacements) {
+    source = source.replace(entry.pattern, () => {
+      convertedAssertions += 1;
+      return entry.replacement;
+    });
+  }
+
+  source = source.replace(/\n{3,}/g, '\n\n');
+
+  return {
+    source,
+    convertedAssertions,
+    removedImports
+  };
+}
+
 function rewriteMigrationImports(projectRoot, matches, compatPath) {
   const rewrittenFiles = [];
   let rewrittenImports = 0;

package/src/reporter.js

@@ -67,7 +67,8 @@ function printAgent(result) {
     failedTests: '.themis/failed-tests.json',
     runDiff: '.themis/run-diff.json',
     runHistory: '.themis/run-history.json',
-    fixHandoff: '.themis/fix-handoff.json'
+    fixHandoff: '.themis/fix-handoff.json',
+    contractDiff: '.themis/contract-diff.json'
   };
 
   const payload = {
@@ -86,7 +87,8 @@ function printAgent(result) {
       rerunFailed: 'npx themis test --rerun-failed',
       targetedRerun: 'npx themis test --match "<regex>"',
       diffLastRun: 'cat .themis/run-diff.json',
-      repairGenerated: 'cat .themis/fix-handoff.json'
+      repairGenerated: 'cat .themis/fix-handoff.json',
+      reviewContracts: 'cat .themis/contract-diff.json'
     }
   };
 
@@ -150,6 +152,8 @@ function printNext(result, options = {}) {
     .slice(0, 5);
 
   const failures = allTests.filter((test) => test.status === 'failed');
+  const contractItems = collectContractItems(files);
+  const notableContracts = contractItems.filter((item) => item.status !== 'unchanged');
 
   console.log('');
   console.log(style.cyan(bannerLine('=')));
@@ -258,10 +262,27 @@ function printNext(result, options = {}) {
     });
   }
 
+  if (notableContracts.length > 0) {
+    console.log('');
+    console.log(style.bold('Contract Diffs'));
+    for (const item of notableContracts.slice(0, 8)) {
+      const tone = item.status === 'drifted'
+        ? style.red(item.status.toUpperCase())
+        : (item.status === 'updated' ? style.yellow(item.status.toUpperCase()) : style.green(item.status.toUpperCase()));
+      console.log(`  ${tone} ${item.fullName} :: ${item.name}`);
+      console.log(`    ${style.dim(item.contractFile)}`);
+      const summaryLine = formatContractDiffSummary(item.diff);
+      if (summaryLine) {
+        console.log(`    ${style.dim(summaryLine)}`);
+      }
+    }
+  }
+
   console.log('');
   console.log(style.bold('Agent Loop Commands'));
   console.log(`  ${style.cyan('rerun failed:')} npx themis test --rerun-failed --reporter next`);
   console.log(`  ${style.cyan('targeted rerun:')} npx themis test --match \"<regex>\" --reporter next`);
+  console.log(`  ${style.cyan('update contracts:')} npx themis test --update-contracts --match \"<regex>\" --reporter next`);
   console.log(style.cyan(bannerLine('=')));
 }
 
@@ -374,6 +395,36 @@ function collectAgentFailures(files) {
   return failures;
 }
 
+function collectContractItems(files) {
+  const items = [];
+  for (const file of files || []) {
+    for (const contract of file.contracts || []) {
+      items.push({
+        ...contract,
+        file: file.file
+      });
+    }
+  }
+  return items;
+}
+
+function formatContractDiffSummary(diff) {
+  if (!diff) {
+    return '';
+  }
+  const parts = [];
+  if (Array.isArray(diff.changed) && diff.changed.length > 0) {
+    parts.push(`${diff.changed.length} changed${diff.changed[0] ? ` (${diff.changed[0].path})` : ''}`);
+  }
+  if (Array.isArray(diff.added) && diff.added.length > 0) {
+    parts.push(`${diff.added.length} added${diff.added[0] ? ` (${diff.added[0].path})` : ''}`);
+  }
+  if (Array.isArray(diff.removed) && diff.removed.length > 0) {
+    parts.push(`${diff.removed.length} removed${diff.removed[0] ? ` (${diff.removed[0].path})` : ''}`);
+  }
+  return parts.join(', ');
+}
+
 function clusterFailures(failures) {
   const byFingerprint = new Map();
 
@@ -464,6 +515,8 @@ function renderHtmlReport(result, options = {}) {
     .slice(0, 8);
 
   const failures = allTests.filter((test) => test.status === 'failed');
+  const contractItems = collectContractItems(files);
+  const notableContracts = contractItems.filter((item) => item.status !== 'unchanged');
   const failureClusters = clusterFailures(collectAgentFailures(files));
   const gateState = stability && stability.runs > 1
     ? (Number(stability.summary?.unstable || 0) === 0 && Number(stability.summary?.stableFail || 0) === 0 ? 'stable' : 'unstable')
@@ -633,6 +686,11 @@ function renderHtmlReport(result, options = {}) {
     '<h2>Quick Actions</h2>' +
     '<div class="action-grid">' +
     [
+      {
+        title: 'Update Contracts',
+        description: 'Accept reviewed contract changes for a narrow slice of the suite.',
+        command: 'npx themis test --update-contracts --match "<regex>" --reporter html'
+      },
       {
         title: failures.length > 0 ? 'Rerun Failed' : 'Rerun Workflow',
         description: failures.length > 0
@@ -697,6 +755,24 @@ function renderHtmlReport(result, options = {}) {
       '</div>' +
       '</section>'
     );
+  const contractDiffPanel = notableContracts.length > 0
+    ? (
+      '<section class="panel insight-panel" id="contracts">' +
+      '<h2>Contract Diffs</h2>' +
+      '<div class="cluster-list">' +
+      notableContracts.slice(0, 10).map((item) => {
+        return (
+          '<article class="cluster-item">' +
+          `<div class="cluster-fingerprint">${escapeHtml(item.status.toUpperCase())}</div>` +
+          `<div class="cluster-message">${escapeHtml(`${item.fullName} :: ${item.name}`)}</div>` +
+          `<div class="cluster-count">${escapeHtml(formatContractDiffSummary(item.diff) || item.contractFile)}</div>` +
+          '</article>'
+        );
+      }).join('\n') +
+      '</div>' +
+      '</section>'
+    )
+    : '';
   const stabilityPanel = stabilitySection
     ? stabilitySection.replace('<section class="panel">', '<section class="panel insight-panel" id="stability">')
     : '';
@@ -706,7 +782,7 @@ function renderHtmlReport(result, options = {}) {
   const slowestPanel = slowestSection
     ? slowestSection.replace('<section class="panel">', '<section class="panel insight-panel" id="slowest">')
     : '';
-  const insightsGrid = [stabilityPanel, failureClusterPanel, slowestPanel].filter(Boolean).join('\n');
+  const insightsGrid = [stabilityPanel, failureClusterPanel, contractDiffPanel, slowestPanel].filter(Boolean).join('\n');
   const triageGrid = [quickActionsSection, focusPanel].join('\n');
 
   return `<!doctype html>

package/src/runner.js

@@ -80,6 +80,7 @@ function runFileInWorker(file, options = {}) {
         match: options.match || null,
         allowedFullNames: Array.isArray(options.allowedFullNames) ? options.allowedFullNames : null,
         noMemes: Boolean(options.noMemes),
+        updateContracts: Boolean(options.updateContracts),
         cwd: options.cwd || process.cwd(),
         environment: options.environment || 'node',
         setupFiles: Array.isArray(options.setupFiles) ? options.setupFiles : [],
@@ -196,6 +197,7 @@ function buildInProcessCacheKey(file, options) {
     match: options.match || null,
     allowedFullNames: Array.isArray(options.allowedFullNames) ? options.allowedFullNames : null,
     noMemes: Boolean(options.noMemes),
+    updateContracts: Boolean(options.updateContracts),
     cwd: options.cwd || process.cwd(),
     environment: options.environment || 'node',
     setupFiles: Array.isArray(options.setupFiles) ? options.setupFiles : [],