@wix/agent-skills 1.15.1 → 1.16.0

package/skills/wix-replatform/lib/artifact-freshness.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const SCHEMA_VERSION = 1;
+
+const DEFAULT_ARTIFACTS = {
+  sourceSchema: 'source-schema.json',
+  mappingPlan: 'mapping/mapping-plan.json',
+  setupVerification: 'setup/setup-verification.json',
+  generatedImportCode: 'src/import',
+};
+
+function sha256Text(text) {
+  return crypto.createHash('sha256').update(text).digest('hex');
+}
+
+function fileHash(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const stat = fs.statSync(filePath);
+  if (!stat.isFile()) return null;
+  return sha256Text(fs.readFileSync(filePath));
+}
+
+function directoryHash(dirPath) {
+  if (!fs.existsSync(dirPath)) return null;
+  const entries = listFilesRecursive(dirPath)
+    .map((file) => {
+      const relative = path.relative(dirPath, file).replace(/\\/g, '/');
+      return `${relative}\0${fileHash(file)}`;
+    })
+    .join('\n');
+  return sha256Text(entries);
+}
+
+function listFilesRecursive(root) {
+  const files = [];
+  const entries = fs.readdirSync(root, { withFileTypes: true })
+    .filter((entry) => !entry.name.startsWith('.'))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listFilesRecursive(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+function hashArtifact(projectDir, relativePath) {
+  if (!relativePath) return null;
+  const absolute = path.resolve(projectDir, relativePath);
+  if (!fs.existsSync(absolute)) return null;
+  const stat = fs.statSync(absolute);
+  if (stat.isDirectory()) return directoryHash(absolute);
+  if (stat.isFile()) return fileHash(absolute);
+  return null;
+}
+
+function targetLedgerRevision(domainsDir) {
+  if (!domainsDir || !fs.existsSync(domainsDir)) return null;
+  return directoryHash(domainsDir);
+}
+
+function createFreshnessMetadata({
+  projectDir,
+  domainsDir,
+  artifactPaths = DEFAULT_ARTIFACTS,
+  generatedImportCodeRevision = null,
+  createdAt = new Date().toISOString(),
+} = {}) {
+  if (!projectDir) throw new Error('projectDir is required');
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    createdAt,
+    artifacts: {
+      sourceSchema: {
+        path: artifactPaths.sourceSchema || DEFAULT_ARTIFACTS.sourceSchema,
+        sha256: hashArtifact(projectDir, artifactPaths.sourceSchema || DEFAULT_ARTIFACTS.sourceSchema),
+      },
+      mappingPlan: {
+        path: artifactPaths.mappingPlan || DEFAULT_ARTIFACTS.mappingPlan,
+        sha256: hashArtifact(projectDir, artifactPaths.mappingPlan || DEFAULT_ARTIFACTS.mappingPlan),
+      },
+      setupVerification: {
+        path: artifactPaths.setupVerification || DEFAULT_ARTIFACTS.setupVerification,
+        sha256: hashArtifact(projectDir, artifactPaths.setupVerification || DEFAULT_ARTIFACTS.setupVerification),
+      },
+      generatedImportCode: {
+        path: artifactPaths.generatedImportCode || DEFAULT_ARTIFACTS.generatedImportCode,
+        sha256: hashArtifact(projectDir, artifactPaths.generatedImportCode || DEFAULT_ARTIFACTS.generatedImportCode),
+        revision: generatedImportCodeRevision,
+      },
+    },
+    targetContractLedger: {
+      path: domainsDir || null,
+      revision: targetLedgerRevision(domainsDir),
+    },
+  };
+}
+
+function compareFreshnessMetadata(current, recorded) {
+  const changes = [];
+  if (!recorded || typeof recorded !== 'object') {
+    return { ok: false, stale: true, changes: [{ field: 'metadata', reason: 'missing' }] };
+  }
+  if (recorded.schemaVersion !== SCHEMA_VERSION) {
+    changes.push({ field: 'schemaVersion', expected: SCHEMA_VERSION, actual: recorded.schemaVersion });
+  }
+  for (const name of Object.keys(current.artifacts || {})) {
+    const currentEntry = current.artifacts[name] || {};
+    const recordedEntry = (recorded.artifacts && recorded.artifacts[name]) || {};
+    if (currentEntry.sha256 !== recordedEntry.sha256) {
+      changes.push({
+        field: `artifacts.${name}.sha256`,
+        path: currentEntry.path || recordedEntry.path || null,
+        expected: recordedEntry.sha256 || null,
+        actual: currentEntry.sha256 || null,
+      });
+    }
+    if (name === 'generatedImportCode' && currentEntry.revision !== recordedEntry.revision) {
+      changes.push({
+        field: 'artifacts.generatedImportCode.revision',
+        expected: recordedEntry.revision || null,
+        actual: currentEntry.revision || null,
+      });
+    }
+  }
+  const currentLedger = current.targetContractLedger || {};
+  const recordedLedger = recorded.targetContractLedger || {};
+  if (currentLedger.revision !== recordedLedger.revision) {
+    changes.push({
+      field: 'targetContractLedger.revision',
+      path: currentLedger.path || recordedLedger.path || null,
+      expected: recordedLedger.revision || null,
+      actual: currentLedger.revision || null,
+    });
+  }
+  return { ok: changes.length === 0, stale: changes.length > 0, changes };
+}
+
+function validateImportPlanFreshness({
+  projectDir,
+  domainsDir,
+  metadataPath = 'execution/review/import-plan.freshness.json',
+  artifactPaths = DEFAULT_ARTIFACTS,
+  generatedImportCodeRevision = null,
+} = {}) {
+  const absoluteMetadataPath = path.resolve(projectDir, metadataPath);
+  const current = createFreshnessMetadata({
+    projectDir,
+    domainsDir,
+    artifactPaths,
+    generatedImportCodeRevision,
+  });
+  if (!fs.existsSync(absoluteMetadataPath)) {
+    return {
+      ok: false,
+      stale: true,
+      current,
+      recorded: null,
+      changes: [{ field: metadataPath, reason: 'missing' }],
+    };
+  }
+  const recorded = JSON.parse(fs.readFileSync(absoluteMetadataPath, 'utf8'));
+  const comparison = compareFreshnessMetadata(current, recorded);
+  return { ...comparison, current, recorded };
+}
+
+function writeFreshnessMetadata(filePath, metadata) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(metadata, null, 2)}\n`);
+}
+
+function renderImportPlanDelta({ staleResult, generatedAt = new Date().toISOString() }) {
+  const lines = [
+    '# Import Plan Delta',
+    '',
+    `Generated: ${generatedAt}`,
+    '',
+    'The approved import plan is stale relative to current artifacts.',
+    '',
+    '## Changed Assumptions',
+    '',
+  ];
+  for (const change of staleResult.changes || []) {
+    const pathPart = change.path ? ` (${change.path})` : '';
+    const reasonPart = change.reason ? `: ${change.reason}` : '';
+    lines.push(`- ${change.field}${pathPart}${reasonPart}`);
+  }
+  lines.push('', 'Regenerate `execution/review/import-plan.md` or accept this delta before live writes/final reporting.');
+  return `${lines.join('\n')}\n`;
+}
+
+function writeImportPlanDelta(filePath, staleResult) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, renderImportPlanDelta({ staleResult }));
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  DEFAULT_ARTIFACTS,
+  createFreshnessMetadata,
+  compareFreshnessMetadata,
+  validateImportPlanFreshness,
+  writeFreshnessMetadata,
+  renderImportPlanDelta,
+  writeImportPlanDelta,
+  hashArtifact,
+  targetLedgerRevision,
+};

package/skills/wix-replatform/lib/completion-report.js

@@ -0,0 +1,200 @@
+'use strict';
+
+const COMPLETION_STATUS = [
+  'aborted',
+  'incomplete_with_mismatches',
+  'incomplete_with_failures',
+  'complete_with_deferred_records',
+  'complete_with_recovered_records',
+  'complete_with_warnings',
+  'complete',
+];
+
+const STATUS_RANK = new Map(COMPLETION_STATUS.map((status, index) => [status, index]));
+
+function count(value, field) {
+  if (value === undefined || value === null) {
+    return 0;
+  }
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${field} must be a non-negative integer`);
+  }
+  return value;
+}
+
+function requireString(value, field) {
+  if (!value || typeof value !== 'string') {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function asArray(value, field) {
+  if (value === undefined || value === null) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`${field} must be an array`);
+  }
+  return value;
+}
+
+function hasCount(rows, field) {
+  return rows.some((row) => row[field] > 0);
+}
+
+function worseStatus(left, right) {
+  const leftRank = STATUS_RANK.has(left) ? STATUS_RANK.get(left) : STATUS_RANK.get('complete');
+  const rightRank = STATUS_RANK.has(right) ? STATUS_RANK.get(right) : STATUS_RANK.get('complete');
+  return leftRank <= rightRank ? left : right;
+}
+
+function chooseCompletionStatus(input = {}) {
+  const statuses = asArray(input.statuses, 'statuses');
+  let selected = input.defaultStatus || 'complete';
+  if (!STATUS_RANK.has(selected)) {
+    throw new Error(`unknown completion status: ${selected}`);
+  }
+
+  for (const status of statuses) {
+    if (!STATUS_RANK.has(status)) {
+      throw new Error(`unknown completion status: ${status}`);
+    }
+    selected = worseStatus(selected, status);
+  }
+
+  if (input.aborted) {
+    selected = worseStatus(selected, 'aborted');
+  }
+  if (input.hasMismatches) {
+    selected = worseStatus(selected, 'incomplete_with_mismatches');
+  }
+  if (input.hasFailures) {
+    selected = worseStatus(selected, 'incomplete_with_failures');
+  }
+  if (input.hasDeferred) {
+    selected = worseStatus(selected, 'complete_with_deferred_records');
+  }
+  if (input.hasRecoveredRecords) {
+    selected = worseStatus(selected, 'complete_with_recovered_records');
+  }
+  if (input.hasWarnings) {
+    selected = worseStatus(selected, 'complete_with_warnings');
+  }
+
+  return selected;
+}
+
+function normalizeCompletenessRow(row, index = 0) {
+  if (!row || typeof row !== 'object' || Array.isArray(row)) {
+    throw new Error(`entityCompleteness[${index}] must be an object`);
+  }
+
+  const entity = requireString(row.entity, `entityCompleteness[${index}].entity`);
+  const subtype = row.subtype === undefined || row.subtype === null ? 'all' : requireString(row.subtype, `entityCompleteness[${index}].subtype`);
+  const extracted = count(row.extracted, `${entity}/${subtype}.extracted`);
+  const inScope = count(row.inScope, `${entity}/${subtype}.inScope`);
+  const attempted = count(row.attempted, `${entity}/${subtype}.attempted`);
+  const imported = count(row.imported, `${entity}/${subtype}.imported`);
+  const alreadyPresentByCrosswalk = count(
+    row.alreadyPresentByCrosswalk === undefined ? row.alreadyPresent : row.alreadyPresentByCrosswalk,
+    `${entity}/${subtype}.alreadyPresentByCrosswalk`
+  );
+  const deferred = count(row.deferred, `${entity}/${subtype}.deferred`);
+  const failed = count(row.failed, `${entity}/${subtype}.failed`);
+  const skippedOutOfScope = count(row.skippedOutOfScope, `${entity}/${subtype}.skippedOutOfScope`);
+  const unexpectedSkipped = count(
+    row.unexpectedSkipped === undefined ? row.skippedInScope : row.unexpectedSkipped,
+    `${entity}/${subtype}.unexpectedSkipped`
+  );
+  const reconciled = imported + alreadyPresentByCrosswalk + deferred + failed;
+  const expectedReconciled = inScope;
+  const mismatch = reconciled !== expectedReconciled || unexpectedSkipped > 0;
+
+  return {
+    entity,
+    subtype,
+    extracted,
+    inScope,
+    attempted,
+    imported,
+    alreadyPresentByCrosswalk,
+    deferred,
+    failed,
+    skippedOutOfScope,
+    unexpectedSkipped,
+    reconciled,
+    expectedReconciled,
+    mismatch,
+    reasons: Array.isArray(row.reasons) ? row.reasons : [],
+  };
+}
+
+function headlineForRow(row) {
+  const parts = [];
+  if (row.mismatch) {
+    parts.push(`mismatch ${row.reconciled}/${row.expectedReconciled}`);
+  }
+  if (row.deferred > 0) {
+    parts.push(`${row.deferred} deferred`);
+  }
+  if (row.failed > 0) {
+    parts.push(`${row.failed} failed`);
+  }
+  if (row.unexpectedSkipped > 0) {
+    parts.push(`${row.unexpectedSkipped} unexpected skipped`);
+  }
+  if (!parts.length) {
+    return null;
+  }
+  return {
+    entity: row.entity,
+    subtype: row.subtype,
+    message: `${row.entity}/${row.subtype}: ${parts.join(', ')}`,
+  };
+}
+
+function createCompletionReport(input = {}) {
+  const entityCompleteness = asArray(input.entityCompleteness, 'entityCompleteness')
+    .map((row, index) => normalizeCompletenessRow(row, index));
+  const mismatches = entityCompleteness.filter((row) => row.mismatch);
+  const headline = entityCompleteness.map(headlineForRow).filter(Boolean);
+  const warnings = asArray(input.warnings, 'warnings');
+  const recoveryActions = asArray(input.recoveryActions, 'recoveryActions');
+  const status = chooseCompletionStatus({
+    statuses: input.statuses,
+    aborted: input.aborted,
+    hasMismatches: mismatches.length > 0,
+    hasFailures: hasCount(entityCompleteness, 'failed'),
+    hasDeferred: hasCount(entityCompleteness, 'deferred'),
+    hasRecoveredRecords: recoveryActions.length > 0 || Boolean(input.hasRecoveredRecords),
+    hasWarnings: warnings.length > 0 || Boolean(input.hasWarnings),
+  });
+
+  return {
+    schemaVersion: 1,
+    runId: input.runId || null,
+    status,
+    headline,
+    entityCompleteness,
+    mismatches: mismatches.map((row) => ({
+      entity: row.entity,
+      subtype: row.subtype,
+      expectedReconciled: row.expectedReconciled,
+      reconciled: row.reconciled,
+      unexpectedSkipped: row.unexpectedSkipped,
+    })),
+    warnings,
+    recoveryActions,
+    artifacts: input.artifacts || {},
+    destinations: input.destinations || {},
+    urlPreservation: input.urlPreservation || null,
+  };
+}
+
+module.exports = {
+  COMPLETION_STATUS,
+  chooseCompletionStatus,
+  createCompletionReport,
+  normalizeCompletenessRow,
+};

package/skills/wix-replatform/lib/config-env.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+
+function parseEnvText(text) {
+  const values = {};
+  const lines = String(text).split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) {
+      continue;
+    }
+    const idx = line.indexOf('=');
+    if (idx === -1) {
+      continue;
+    }
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1);
+    values[key] = value;
+  }
+  return values;
+}
+
+async function readEnvFile(filePath) {
+  const raw = await fs.readFile(filePath, 'utf8');
+  return parseEnvText(raw);
+}
+
+async function statEnvKeys(filePath, requiredKeys) {
+  try {
+    const values = await readEnvFile(filePath);
+    const keys = {};
+    for (const key of requiredKeys) {
+      if (!(key in values)) {
+        keys[key] = 'missing';
+      } else if (String(values[key]).trim() === '') {
+        keys[key] = 'blank';
+      } else {
+        keys[key] = 'present';
+      }
+    }
+    return { exists: true, keys };
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      const keys = {};
+      for (const key of requiredKeys) {
+        keys[key] = 'missing';
+      }
+      return { exists: false, keys };
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  parseEnvText,
+  readEnvFile,
+  statEnvKeys,
+};

package/skills/wix-replatform/lib/execution-manifest.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const SCHEMA_VERSION = 1;
+
+const TASK_KIND = new Set(['setup', 'extract', 'import']);
+const TASK_STATUS = new Set(['pending', 'running', 'completed', 'blocked', 'failed', 'skipped']);
+const CROSSWALK_AUTHORITY = new Set(['local']);
+const CMS_MIRROR_MODE = new Set(['none', 'download', 'upload', 'download-and-upload']);
+const URL_PRESERVATION_PATHS = [
+  'basePathsPath',
+  'ledgerPath',
+  'redirectsPath',
+  'unresolvedPath',
+];
+
+function createManifest({ projectId, planVersion, tasks = [], generatedArtifacts = [], llmHandoff = null, timestamp = new Date().toISOString() }) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    projectId,
+    planVersion,
+    generatedAt: timestamp,
+    generatedArtifacts,
+    tasks,
+    llmHandoff,
+  };
+}
+
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest || typeof manifest !== 'object') {
+    errors.push('manifest must be an object');
+    return { ok: false, errors };
+  }
+  if (manifest.schemaVersion !== SCHEMA_VERSION) {
+    errors.push(`schemaVersion must be ${SCHEMA_VERSION}`);
+  }
+  if (!manifest.projectId || typeof manifest.projectId !== 'string') {
+    errors.push('projectId must be a non-empty string');
+  }
+  if (!manifest.planVersion || typeof manifest.planVersion !== 'string') {
+    errors.push('planVersion must be a non-empty string');
+  }
+  if (!Array.isArray(manifest.generatedArtifacts)) {
+    errors.push('generatedArtifacts must be an array');
+  }
+  if (!Array.isArray(manifest.tasks) || manifest.tasks.length === 0) {
+    errors.push('tasks must be a non-empty array');
+  } else {
+    const ids = new Set();
+    for (const task of manifest.tasks) {
+      if (!task || typeof task !== 'object') {
+        errors.push('task must be an object');
+        continue;
+      }
+      if (!task.id || typeof task.id !== 'string') {
+        errors.push('task.id must be a non-empty string');
+      } else if (ids.has(task.id)) {
+        errors.push(`duplicate task id: ${task.id}`);
+      } else {
+        ids.add(task.id);
+      }
+      if (!TASK_KIND.has(task.kind)) {
+        errors.push(`task.kind invalid for ${task.id || '<unknown>'}`);
+      }
+      if (task.status && !TASK_STATUS.has(task.status)) {
+        errors.push(`task.status invalid for ${task.id || '<unknown>'}`);
+      }
+      if (!Array.isArray(task.dependsOn)) {
+        errors.push(`task.dependsOn must be an array for ${task.id || '<unknown>'}`);
+      }
+      if (!Array.isArray(task.artifactRefs)) {
+        errors.push(`task.artifactRefs must be an array for ${task.id || '<unknown>'}`);
+      }
+      validateUrlPreservation(task, errors);
+      if (task.kind === 'import') {
+        validateImportTaskState(task, errors);
+      }
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+function validateUrlPreservation(task, errors) {
+  if (task.urlPreservation === undefined) {
+    return;
+  }
+  const label = task.id || '<unknown>';
+  if (task.kind !== 'import') {
+    errors.push(`task.urlPreservation is only allowed for import tasks in ${label}`);
+  }
+  const policy = task.urlPreservation;
+  if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
+    errors.push(`task.urlPreservation must be an object for ${label}`);
+    return;
+  }
+  if (policy.enabled !== undefined && typeof policy.enabled !== 'boolean') {
+    errors.push(`task.urlPreservation.enabled must be a boolean for ${label}`);
+  }
+  if (policy.applyRedirects === true) {
+    errors.push(`task.urlPreservation.applyRedirects must be false until website-builder redirect application is supported for ${label}`);
+  }
+  if (policy.applyRedirects !== undefined && typeof policy.applyRedirects !== 'boolean') {
+    errors.push(`task.urlPreservation.applyRedirects must be a boolean for ${label}`);
+  }
+  if (policy.enabled === true) {
+    for (const field of URL_PRESERVATION_PATHS) {
+      if (!policy[field] || typeof policy[field] !== 'string') {
+        errors.push(`task.urlPreservation.${field} required when enabled for ${label}`);
+      }
+    }
+    if (policy.applyRedirects !== false) {
+      errors.push(`task.urlPreservation.applyRedirects must be false when enabled for ${label}`);
+    }
+  }
+}
+
+function hasServerAssignedNativeTargetIds(task) {
+  return task.targetIdAssignment === 'server' ||
+    task.targetIdAssignment === 'server-assigned' ||
+    task.nativeTargetIds === 'server-assigned' ||
+    task.targetIdsServerAssigned === true;
+}
+
+function validateCmsMirror(task, state, errors) {
+  if (!state.cmsMirror || typeof state.cmsMirror !== 'object') {
+    return;
+  }
+  const mode = state.cmsMirror.mode;
+  if (!CMS_MIRROR_MODE.has(mode)) {
+    errors.push(`task.state.cmsMirror.mode invalid for ${task.id || '<unknown>'}`);
+    return;
+  }
+  if (mode !== 'none') {
+    if (!state.cmsMirror.collectionId || typeof state.cmsMirror.collectionId !== 'string') {
+      errors.push(`task.state.cmsMirror.collectionId required when CMS mirror is enabled for ${task.id || '<unknown>'}`);
+    }
+    if (!state.cmsMirror.setupRequirementId || typeof state.cmsMirror.setupRequirementId !== 'string') {
+      errors.push(`task.state.cmsMirror.setupRequirementId required when CMS mirror is enabled for ${task.id || '<unknown>'}`);
+    }
+  }
+}
+
+function validateImportTaskState(task, errors) {
+  const state = task.state;
+  if (!state || typeof state !== 'object') {
+    if (hasServerAssignedNativeTargetIds(task)) {
+      errors.push(`task.state required for server-assigned native target IDs in ${task.id || '<unknown>'}`);
+    }
+    return;
+  }
+  if (state.crosswalkAuthority === 'cms') {
+    errors.push(`task.state.crosswalkAuthority must not be cms for ${task.id || '<unknown>'}`);
+  }
+  if (state.crosswalkAuthority !== undefined && !CROSSWALK_AUTHORITY.has(state.crosswalkAuthority)) {
+    errors.push(`task.state.crosswalkAuthority invalid for ${task.id || '<unknown>'}`);
+  }
+  if (hasServerAssignedNativeTargetIds(task) && (!state.crosswalkPath || typeof state.crosswalkPath !== 'string')) {
+    errors.push(`task.state.crosswalkPath required for server-assigned native target IDs in ${task.id || '<unknown>'}`);
+  }
+  if (state.attemptJournalPath !== undefined && typeof state.attemptJournalPath !== 'string') {
+    errors.push(`task.state.attemptJournalPath must be a string for ${task.id || '<unknown>'}`);
+  }
+  validateCmsMirror(task, state, errors);
+}
+
+function nextPendingTask(manifest, completedIds = new Set()) {
+  const done = completedIds instanceof Set ? completedIds : new Set(completedIds || []);
+  for (const task of manifest.tasks || []) {
+    if (task.status === 'completed' || done.has(task.id)) {
+      continue;
+    }
+    const deps = Array.isArray(task.dependsOn) ? task.dependsOn : [];
+    if (deps.every((dep) => done.has(dep))) {
+      return task;
+    }
+  }
+  return null;
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  createManifest,
+  validateManifest,
+  nextPendingTask,
+};