@entelligentsia/forgecli 0.8.4 → 0.9.0

package/dist/forge-payload/.tools/validate-store.cjs

@@ -1,593 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// Forge tool: validate-store
-// Check store integrity: required fields, types, enums, and referential integrity.
-// Usage: validate-store [--dry-run] [--fix] [--json]
-
-let _store;
-function _getStore() { return _store || (_store = require('./store.cjs')); }
-
-let _schemas;
-function _getSchemas() {
-  if (_schemas) return _schemas;
-  const fs = require('fs');
-  const path = require('path');
-
-  const ENTITY_TYPES = ['sprint', 'task', 'bug', 'event', 'feature'];
-
-  const MINIMAL_REQUIRED = {
-    sprint:  ['sprintId', 'title', 'status', 'taskIds', 'createdAt'],
-    task:    ['taskId', 'sprintId', 'title', 'status', 'path'],
-    bug:     ['bugId', 'title', 'severity', 'status', 'path', 'reportedAt'],
-    event:   ['eventId', 'taskId', 'sprintId', 'role', 'action', 'phase', 'iteration', 'startTimestamp', 'endTimestamp', 'durationMinutes', 'model'],
-    feature: ['id', 'title', 'status', 'created_at']
-  };
-
-  const schemas = {};
-  const projectDir   = path.join('.forge', 'schemas');
-  const inTreeDir    = path.join('forge', 'schemas');
-  const pluginDir    = path.join(__dirname, '..', 'schemas');
-
-  for (const type of ENTITY_TYPES) {
-    const schemaFile = `${type}.schema.json`;
-    let schema = null;
-
-    // 1. Try project-installed schemas first
-    const projectPath = path.join(projectDir, schemaFile);
-    try {
-      if (fs.existsSync(projectPath)) {
-        schema = JSON.parse(fs.readFileSync(projectPath, 'utf8'));
-      }
-    } catch (e) {
-      console.error(`WARN: schema file ${projectPath} exists but could not be parsed: ${e.message}`);
-    }
-
-    // 2. Fall back to in-tree source schemas (development mode)
-    if (!schema) {
-      const inTreePath = path.join(inTreeDir, schemaFile);
-      try {
-        if (fs.existsSync(inTreePath)) {
-          schema = JSON.parse(fs.readFileSync(inTreePath, 'utf8'));
-        }
-      } catch (e) {
-        console.error(`WARN: schema file ${inTreePath} exists but could not be parsed: ${e.message}`);
-      }
-    }
-
-    // 3. Fall back to plugin-installed schemas (production mode)
-    //    validate-store.cjs lives at $FORGE_ROOT/tools/, so __dirname/../schemas/
-    //    resolves to $FORGE_ROOT/schemas/ — always correct for installed plugins.
-    if (!schema) {
-      const pluginPath = path.join(pluginDir, schemaFile);
-      try {
-        if (fs.existsSync(pluginPath)) {
-          schema = JSON.parse(fs.readFileSync(pluginPath, 'utf8'));
-        }
-      } catch (e) {
-        console.error(`WARN: schema file ${pluginPath} exists but could not be parsed: ${e.message}`);
-      }
-    }
-
-    if (schema) {
-      schemas[type] = schema;
-    } else {
-      console.error(`WARN: schema file ${schemaFile} not found in ${projectDir}, ${inTreeDir}, or ${pluginDir}, using minimal fallback`);
-      schemas[type] = { type: 'object', required: MINIMAL_REQUIRED[type] || [], properties: {} };
-    }
-  }
-
-  _schemas = schemas;
-  return _schemas;
-}
-
-// ---------------------------------------------------------------------------
-// Constants (exported for testing)
-// ---------------------------------------------------------------------------
-
-const ENTITY_TYPES = ['sprint', 'task', 'bug', 'event', 'feature'];
-
-// Non-entity schemas: referenced and parsed for validity but not used for store record validation.
-const ANCILLARY_SCHEMAS = ['project-overlay', 'project-context', 'structure-versions'];
-
-const MINIMAL_REQUIRED = {
-  sprint:  ['sprintId', 'title', 'status', 'taskIds', 'createdAt'],
-  task:    ['taskId', 'sprintId', 'title', 'status', 'path'],
-  bug:     ['bugId', 'title', 'severity', 'status', 'path', 'reportedAt'],
-  event:   ['eventId', 'taskId', 'sprintId', 'role', 'action', 'phase', 'iteration', 'startTimestamp', 'endTimestamp', 'durationMinutes', 'model'],
-  feature: ['id', 'title', 'status', 'created_at']
-};
-
-// Fields that are legitimately null:
-//   sprintId / taskId  — optional FK (e.g. standalone bug fix has no sprint)
-//   endTimestamp / durationMinutes — not recorded on "start" events (phase opened but never closed)
-const NULLABLE_FK = new Set(['sprintId', 'taskId', 'endTimestamp', 'durationMinutes']);
-
-// --- Validation ---
-function validateRecord(record, schema) {
-  const errors = [];
-  const required = schema.required || [];
-
-  for (const field of required) {
-    if (record[field] === undefined || record[field] === '') {
-      errors.push({ category: 'missing-required', field, message: `missing required field: "${field}"`, value: record[field], expected: null });
-    } else if (record[field] === null && !NULLABLE_FK.has(field)) {
-      errors.push({ category: 'missing-required', field, message: `missing required field: "${field}"`, value: null, expected: null });
-    }
-  }
-
-  for (const [field, def] of Object.entries(schema.properties || {})) {
-    const val = record[field];
-    if (val === undefined) continue;
-    if (val === null) continue;
-
-    if (def.type) {
-      const typeMatches = (expected, actualVal) => {
-        return expected === 'integer' ? Number.isInteger(actualVal)
-             : expected === 'number'  ? typeof actualVal === 'number'
-             : expected === 'array'   ? Array.isArray(actualVal)
-             : typeof actualVal === expected;
-      };
-      const ok = Array.isArray(def.type)
-        ? def.type.some(t => typeMatches(t, val))
-        : typeMatches(def.type, val);
-      if (!ok) errors.push({ category: 'type-mismatch', field, message: `field "${field}": expected ${def.type}, got ${Array.isArray(val) ? 'array' : typeof val}`, value: val, expected: String(def.type) });
-    }
-    if (def.enum && !def.enum.includes(val)) {
-      errors.push({ category: 'invalid-enum', field, message: `field "${field}": value "${val}" not in [${def.enum.join(', ')}]`, value: String(val), expected: def.enum });
-    }
-    if (def.minimum !== undefined && typeof val === 'number' && val < def.minimum) {
-      errors.push({ category: 'minimum-violation', field, message: `field "${field}": value ${val} is below minimum ${def.minimum}`, value: val, expected: String(def.minimum) });
-    }
-    // FORGE-S20-T01 — minimal `pattern` interpreter for string fields. Strictly
-    // additive: schemas without `pattern` see no behavior change. Used by the
-    // friction `subkind` slot to encode "frozen enum OR ^x_[a-z_]+$" as a
-    // single combined regex (neither validator supports `anyOf`).
-    if (def.pattern && typeof val === 'string') {
-      let re;
-      try { re = new RegExp(def.pattern); }
-      catch (_) {
-        errors.push({
-          category: 'pattern-invalid',
-          field,
-          message:  `field "${field}": schema pattern "${def.pattern}" is not a valid regex`,
-          value:    String(val),
-          expected: String(def.pattern),
-        });
-        re = null;
-      }
-      if (re && !re.test(val)) {
-        errors.push({
-          category: 'pattern-mismatch',
-          field,
-          message:  `field "${field}": value "${val}" does not match pattern ${def.pattern}`,
-          value:    String(val),
-          expected: String(def.pattern),
-        });
-      }
-    }
-  }
-
-  // Check for undeclared fields when additionalProperties is false
-  if (schema.additionalProperties === false) {
-    const allowed = new Set([...required, ...Object.keys(schema.properties || {})]);
-    for (const key of Object.keys(record)) {
-      if (!allowed.has(key)) {
-        errors.push({ category: 'undeclared-field', field: key, message: `undeclared field: "${key}"`, value: record[key], expected: null });
-      }
-    }
-  }
-
-  // Conditional required via JSON-Schema `allOf` with `if/then/required`.
-  // FORGE-S20-T00 — minimal interpreter: each clause may carry an `if` whose
-  // `properties.<field>.const` must equal `record[field]`, AND every field in
-  // `if.required` must be present on the record. When the clause matches,
-  // every name in `then.required` becomes an additional required field.
-  // No other JSON-Schema constructs are honored — this is intentional; the
-  // store schemas are thin and we don't want to drag in a full validator.
-  if (Array.isArray(schema.allOf)) {
-    for (const clause of schema.allOf) {
-      if (!clause || typeof clause !== 'object' || !clause.if || !clause.then) continue;
-      const condProps = (clause.if.properties && typeof clause.if.properties === 'object')
-        ? clause.if.properties
-        : {};
-      const condRequired = Array.isArray(clause.if.required) ? clause.if.required : [];
-
-      // All `if.required` fields must be present on the record.
-      const allReqPresent = condRequired.every((f) => record[f] !== undefined && record[f] !== null && record[f] !== '');
-      if (!allReqPresent) continue;
-
-      // Every const predicate in `if.properties` must match the record.
-      let condMatches = true;
-      for (const [field, pred] of Object.entries(condProps)) {
-        if (pred && Object.prototype.hasOwnProperty.call(pred, 'const')) {
-          if (record[field] !== pred.const) { condMatches = false; break; }
-        }
-      }
-      if (!condMatches) continue;
-
-      // Clause fired — enforce `then.required`.
-      const thenRequired = Array.isArray(clause.then.required) ? clause.then.required : [];
-      for (const field of thenRequired) {
-        if (record[field] === undefined || record[field] === null || record[field] === '') {
-          errors.push({
-            category: 'missing-required',
-            field,
-            message: `missing required field: "${field}"`,
-            value:    record[field],
-            expected: null,
-          });
-        }
-      }
-    }
-  }
-
-  return errors;
-}
-
-// --- Backfill defaults for --fix mode ---
-const BACKFILL = {
-  sprint: {
-    createdAt: (rec) => rec.completedAt || rec.startDate || rec.endDate || new Date().toISOString(),
-  },
-  bug: {
-    reportedAt: (rec) => rec.resolvedAt || new Date().toISOString(),
-  },
-  event: {
-    eventId:         (_rec, id) => id,
-    role:            (rec)        => rec.agent || 'unknown',
-    action:          (rec)        => rec.phase  || 'unknown',
-    phase:           (rec)        => rec.action || 'unknown',
-    iteration:       ()           => 1,
-    startTimestamp:  (rec)        => rec.timestamp || new Date().toISOString(),
-    endTimestamp:    (rec)        => rec.timestamp || null,
-    durationMinutes: ()           => null,
-    model: (rec) => {
-      if (rec.actor && typeof rec.actor === 'string' && rec.actor.includes('claude')) return rec.actor;
-      return 'unknown';
-    },
-  },
-};
-
-module.exports = { validateRecord, MINIMAL_REQUIRED, NULLABLE_FK, BACKFILL, ENTITY_TYPES, ANCILLARY_SCHEMAS };
-
-// ---------------------------------------------------------------------------
-// CLI
-// ---------------------------------------------------------------------------
-if (require.main === module) {
-
-process.on('uncaughtException', (error) => {
-  console.error('Fatal validate-store error:', error);
-  process.exit(1);
-});
-
-const fs = require('fs');
-const path = require('path');
-const store = _getStore();
-const schemas = _getSchemas();
-
-const DRY_RUN = process.argv.includes('--dry-run');
-const FIX_MODE = process.argv.includes('--fix');
-const JSON_MODE = process.argv.includes('--json');
-
-// Read engineering root and project prefix from config for filesystem consistency checks
-const CONFIG_PATH = '.forge/config.json';
-let engineeringRoot = 'engineering';
-let projectPrefix = '[A-Z]+';
-try {
-  const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
-  if (cfg.paths && cfg.paths.engineering) engineeringRoot = cfg.paths.engineering;
-  if (cfg.project && cfg.project.prefix) projectPrefix = cfg.project.prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-} catch (_) {}
-
-// Slug-aware directory discovery regexes
-const SPRINT_DIR_RE = new RegExp(`^(${projectPrefix}-S\\d+)(-\\S+)?$`);
-const TASK_FULL_RE  = new RegExp(`^(${projectPrefix}-S\\d+-T\\d+)(-\\S+)?$`);
-const TASK_SHORT_RE = /^(T\d+)(-\S+)?$/;
-
-let errorsCount = 0;
-let warningsCount = 0;
-let fixesCount = 0;
-
-// Structured collections for --json mode
-const jsonErrors = [];
-const jsonWarnings = [];
-const jsonFixes = [];
-
-function err(id, msg, category, field, value, expected) {
-  errorsCount++;
-  if (JSON_MODE) {
-    jsonErrors.push({ entity: id.split('/')[0].split('-')[0] || 'unknown', id, category: category || 'unknown', field: field || null, message: msg, value: value || null, expected: expected || null });
-  } else {
-    console.error(`ERROR  ${id}: ${msg}`);
-  }
-}
-
-function warn(id, msg, category, field) {
-  warningsCount++;
-  if (JSON_MODE) {
-    jsonWarnings.push({ entity: id.split('/')[0].split('-')[0] || 'unknown', id, category: category || 'unknown', field: field || null, message: msg });
-  } else {
-    console.log(`WARN   ${id}: ${msg}`);
-  }
-}
-
-function fixMsg(id, msg, category, field) {
-  fixesCount++;
-  if (JSON_MODE) {
-    jsonFixes.push({ entity: id.split('/')[0].split('-')[0] || 'unknown', id, category: category || 'backfill', field: field || null, message: msg, applied: !DRY_RUN });
-  } else {
-    console.log(`FIXED  ${id}: ${msg}`);
-  }
-}
-
-function backfillRecord(id, rec, type) {
-  const rules = BACKFILL[type];
-  if (!rules) return false;
-  let changed = false;
-  for (const [field, derive] of Object.entries(rules)) {
-    if (rec[field] === undefined || rec[field] === null || rec[field] === '') {
-      const val = derive(rec, id);
-      rec[field] = val;
-      fixMsg(id, `backfilled "${field}" = "${val}"`, 'backfill', field);
-      changed = true;
-    }
-  }
-  if (changed) {
-    // In dry-run mode, preview the fix without writing
-    if (DRY_RUN) return changed;
-    // Facade write uses the logic in FSImpl to maintain formatting
-    if (type === 'sprint') store.writeSprint(rec);
-    else if (type === 'task') store.writeTask(rec);
-    else if (type === 'bug') store.writeBug(rec);
-    else if (type === 'feature') store.writeFeature(rec);
-    // Events are slightly different as they need sprintId
-    else if (type === 'event') {
-      // We'll handle event writing in the loop where sprintId is known
-    }
-  }
-  return changed;
-}
-
-// Load all records up-front for referential integrity checks
-const sprintIds = new Set();
-const taskIds   = new Set();
-const bugIds    = new Set();
-const featureIds = new Set();
-
-// --- Pass 1: validate structure, collect IDs ---
-const sprints = store.listSprints();
-for (const rec of sprints) {
-  if (!rec) continue;
-  if (FIX_MODE) backfillRecord(rec.sprintId, rec, 'sprint');
-  if (rec.sprintId) sprintIds.add(rec.sprintId);
-  for (const e of validateRecord(rec, schemas.sprint)) err(rec.sprintId, e.message, e.category, e.field, e.value, e.expected);
-  if (!rec.path) warn(rec.sprintId, 'missing optional field "path"', 'missing-optional', 'path');
-}
-
-const tasks = store.listTasks();
-for (const rec of tasks) {
-  if (!rec) continue;
-  if (rec.taskId) taskIds.add(rec.taskId);
-  for (const e of validateRecord(rec, schemas.task)) err(rec.taskId, e.message, e.category, e.field, e.value, e.expected);
-}
-
-const bugs = store.listBugs();
-for (const rec of bugs) {
-  if (!rec) continue;
-  if (FIX_MODE) backfillRecord(rec.bugId, rec, 'bug');
-  if (rec.bugId) bugIds.add(rec.bugId);
-  for (const e of validateRecord(rec, schemas.bug)) err(rec.bugId, e.message, e.category, e.field, e.value, e.expected);
-}
-
-const features = store.listFeatures();
-for (const rec of features) {
-  if (!rec) continue;
-  const featureId = rec.id || 'unknown';
-  featureIds.add(featureId);
-}
-
-// --- Pass 2: referential integrity ---
-for (const rec of sprints) {
-  if (!rec) continue;
-  if (rec.feature_id && !featureIds.has(rec.feature_id)) {
-    if (FIX_MODE) {
-      rec.feature_id = null;
-      if (!DRY_RUN) store.writeSprint(rec);
-      fixMsg(rec.sprintId, `nullified orphaned feature_id "${rec.feature_id}"`, 'orphaned-fk', 'feature_id');
-    } else {
-      err(rec.sprintId, `feature_id "${rec.feature_id}" references unknown feature`, 'orphaned-fk', 'feature_id', rec.feature_id);
-    }
-  }
-}
-
-for (const rec of tasks) {
-  if (!rec) continue;
-  if (rec.sprintId && !sprintIds.has(rec.sprintId))
-    err(rec.taskId, `sprintId "${rec.sprintId}" references unknown sprint`, 'orphaned-fk', 'sprintId', rec.sprintId);
-
-  if (rec.feature_id && !featureIds.has(rec.feature_id)) {
-    if (FIX_MODE) {
-      rec.feature_id = null;
-      if (!DRY_RUN) store.writeTask(rec);
-      fixMsg(rec.taskId, `nullified orphaned feature_id "${rec.feature_id}"`, 'orphaned-fk', 'feature_id');
-    } else {
-      err(rec.taskId, `feature_id "${rec.feature_id}" references unknown feature`, 'orphaned-fk', 'feature_id', rec.feature_id);
-    }
-  }
-}
-
-for (const rec of bugs) {
-  if (!rec) continue;
-  for (const ref of (rec.similarBugs || [])) {
-    if (!bugIds.has(ref)) err(rec.bugId, `similarBugs references unknown bug "${ref}"`, 'orphaned-fk', 'similarBugs', ref);
-  }
-}
-
-// --- Events ---
-const allSprints = store.listSprints();
-for (const sprint of allSprints) {
-  if (!sprint) continue;
-  const sprintId = sprint.sprintId;
-  const eventFileEntries = store.listEventFilenames(sprintId)
-    .filter(entry => !entry.id.startsWith('_'));
-
-  for (const entry of eventFileEntries) {
-    const filename = entry.id; // filename without .json extension
-    const rec = store.getEvent(filename, sprintId);
-    if (!rec) continue;
-
-    const eventId = rec.eventId;
-
-    if (FIX_MODE) {
-      const rules = BACKFILL.event;
-      let changed = false;
-      for (const [field, derive] of Object.entries(rules)) {
-        if (rec[field] === undefined || rec[field] === null || rec[field] === '') {
-          const val = derive(rec, filename);
-          rec[field] = val;
-          fixMsg(`${sprintId}/${filename}`, `backfilled "${field}" = "${val}"`, 'backfill', field);
-          changed = true;
-        }
-      }
-
-      // If the filename doesn't match the canonical eventId, resolve the mismatch.
-      // When the eventId is a valid filename, rename the file to match it.
-      // When the eventId is invalid (contains /, is a placeholder like "temp",
-      // or cannot be a filename), backfill eventId to the filename instead.
-      if (filename !== rec.eventId) {
-        const isValidFilename = (id) => id && !id.includes('/') && !id.includes('\\') && id !== '.';
-        if (isValidFilename(rec.eventId)) {
-          if (!DRY_RUN) {
-            try {
-              store.renameEvent(sprintId, filename, rec.eventId);
-            } catch (renameErr) {
-              err(`${sprintId}/${filename}`, `cannot rename to ${rec.eventId}.json: ${renameErr.message}`, 'filename-mismatch', 'eventId');
-            }
-          }
-          fixMsg(`${sprintId}/${filename}`, `renamed to ${rec.eventId}.json`, 'filename-mismatch', 'eventId');
-        } else {
-          // eventId is invalid for a filename — backfill it to the current filename
-          fixMsg(`${sprintId}/${filename}`, `eventId "${rec.eventId}" is not a valid filename, resetting to "${filename}"`, 'filename-mismatch', 'eventId');
-          rec.eventId = filename;
-          changed = true;
-        }
-      }
-
-      // Write the updated record (writeEvent now handles ghost detection internally)
-      if (changed && !DRY_RUN) store.writeEvent(sprintId, rec);
-    }
-
-    for (const e of validateRecord(rec, schemas.event)) err(`${sprintId}/${eventId}`, e.message, e.category, e.field, e.value, e.expected);
-    if (rec.taskId && !taskIds.has(rec.taskId) && !bugIds.has(rec.taskId))
-      err(`${sprintId}/${eventId}`, `taskId "${rec.taskId}" references unknown task or bug`, 'orphaned-fk', 'taskId', rec.taskId);
-    if (rec.sprintId && !sprintIds.has(rec.sprintId) && rec.sprintId !== sprintId)
-      err(`${sprintId}/${eventId}`, `sprintId "${rec.sprintId}" references unknown sprint`, 'orphaned-fk', 'sprintId', rec.sprintId);
-  }
-}
-
-// --- Pass 3: Filesystem consistency ---
-// Walk engineering/sprints/ to detect orphaned directories and dangling path fields.
-// All checks here emit warnings (not errors) for backward compatibility.
-const sprintsDir = path.join(engineeringRoot, 'sprints');
-if (fs.existsSync(sprintsDir)) {
-  let sprintEntries;
-  try { sprintEntries = fs.readdirSync(sprintsDir); } catch (_) { sprintEntries = []; }
-
-  for (const entry of sprintEntries) {
-    const entryPath = path.join(sprintsDir, entry);
-    let isDir = false;
-    try { isDir = fs.statSync(entryPath).isDirectory(); } catch (_) {}
-    if (!isDir) continue;
-
-    const sprintMatch = SPRINT_DIR_RE.exec(entry);
-    if (!sprintMatch) continue; // not a recognised sprint directory pattern — skip silently
-    const dirSprintId = sprintMatch[1];
-
-    if (!sprintIds.has(dirSprintId)) {
-      warn(dirSprintId, `directory "${entry}" has no sprint record in store`, 'orphan-directory');
-      continue; // no point walking tasks for an unregistered sprint
-    }
-
-    // Walk for task subdirectories
-    let taskEntries;
-    try { taskEntries = fs.readdirSync(entryPath); } catch (_) { taskEntries = []; }
-
-    for (const taskEntry of taskEntries) {
-      const taskEntryPath = path.join(entryPath, taskEntry);
-      let isTaskDir = false;
-      try { isTaskDir = fs.statSync(taskEntryPath).isDirectory(); } catch (_) {}
-      if (!isTaskDir) continue;
-
-      let dirTaskId = null;
-
-      const taskFullMatch = TASK_FULL_RE.exec(taskEntry);
-      if (taskFullMatch) {
-        dirTaskId = taskFullMatch[1];
-      } else {
-        const taskShortMatch = TASK_SHORT_RE.exec(taskEntry);
-        if (taskShortMatch) {
-          // Construct full task ID from sprint ID + short task number (e.g. T09 → FORGE-S06-T09)
-          dirTaskId = `${dirSprintId}-${taskShortMatch[1]}`;
-        }
-      }
-
-      if (!dirTaskId) continue; // not a recognised task directory pattern — skip silently
-
-      if (!taskIds.has(dirTaskId)) {
-        warn(dirTaskId, `directory "${entry}/${taskEntry}" has no task record in store`, 'orphan-directory');
-      }
-    }
-  }
-}
-
-// path field cross-check for sprints
-for (const rec of sprints) {
-  if (!rec || !rec.path) continue;
-  if (!fs.existsSync(rec.path)) {
-    warn(rec.sprintId, `path "${rec.path}" does not exist on disk`, 'stale-path', 'path');
-  }
-}
-
-// path field cross-check for tasks
-for (const rec of tasks) {
-  if (!rec || !rec.path) continue;
-  if (!fs.existsSync(rec.path)) {
-    warn(rec.taskId, `path "${rec.path}" does not exist on disk`, 'stale-path', 'path');
-  }
-}
-
-// --- Result ---
-if (JSON_MODE) {
-  const result = {
-    ok: errorsCount === 0,
-    errors: jsonErrors,
-    warnings: jsonWarnings,
-    fixes: jsonFixes,
-    summary: {
-      sprints: sprintIds.size,
-      tasks: taskIds.size,
-      bugs: bugIds.size,
-      features: featureIds.size,
-      errors: errorsCount,
-      warnings: warningsCount,
-      fixes: fixesCount
-    }
-  };
-  console.log(JSON.stringify(result, null, 2));
-  process.exit(errorsCount === 0 ? 0 : 1);
-} else {
-  if (fixesCount > 0) {
-    console.log(`${fixesCount} field(s) backfilled.`);
-  }
-  if (errorsCount === 0) {
-    console.log(`Store validation passed (${sprintIds.size} sprint(s), ${taskIds.size} task(s), ${bugIds.size} bug(s)).`);
-    if (warningsCount > 0) console.log(`${warningsCount} warning(s).`);
-    process.exit(0);
-  } else {
-    console.error(`\n${errorsCount} error(s) found.`);
-    process.exit(1);
-  }
-}
-
-} // end if (require.main === module)