forge-workflow 0.1.0-beta.3 → 0.1.0-beta.5

package/scripts/forge-team/tests/dashboard.test.sh

@@ -1,155 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-# ── Setup temp dir for test isolation ────────────────────────────────────
-TEST_TMP="$(mktemp -d)"
-trap 'rm -rf "$TEST_TMP"' EXIT
-
-# ── Create mock forge ─────────────────────────────────────────────────────
-# Emits Kernel-shaped JSON ({"data":{"issues":[...]}}) for `issue list`.
-mock_dir="$(mktemp -d)"
-
-cat > "$mock_dir/forge" << 'MOCK'
-#!/usr/bin/env bash
-args="$*"
-emit() { printf '{"data":{"issues":%s}}\n' "$1"; }
-
-# forge-aaa BLOCKS forge-ccc (kernel: blocker carries the dependency edge), so
-# forge-ccc is the blocked one — its blocked_by resolves to forge-aaa via reverse scan.
-aaa='{"id":"forge-aaa","title":"Feature A","status":"in_progress","assignee":"devone","updated_at":"2026-03-27T10:00:00Z","dependencies":["forge-ccc"]}'
-bbb='{"id":"forge-bbb","title":"Feature B","status":"open","assignee":"devtwo","updated_at":"2026-03-24T10:00:00Z","dependencies":[]}'
-ccc='{"id":"forge-ccc","title":"Feature C","status":"in_progress","assignee":"devone","updated_at":"2026-03-27T09:00:00Z","dependencies":[]}'
-
-if [[ "$args" == *"issue list"* ]]; then
-  if [[ -n "${FORGE_MOCK_EMPTY:-}" ]]; then
-    emit "[]"
-  elif [[ -n "${FORGE_MOCK_SINGLE:-}" ]]; then
-    if [[ "$args" == *"--status=in_progress"* ]]; then emit "[$aaa]"; else emit "[]"; fi
-  else
-    if [[ "$args" == *"--status=open"* ]]; then emit "[$bbb]"
-    elif [[ "$args" == *"--status=in_progress"* ]]; then emit "[$aaa,$ccc]"
-    else emit "[]"; fi
-  fi
-  exit 0
-fi
-exit 0
-MOCK
-chmod +x "$mock_dir/forge"
-
-export FORGE_CMD="$mock_dir/forge"
-
-# Source the library under test
-source "$SCRIPT_DIR/lib/dashboard.sh"
-
-PASS=0
-FAIL=0
-
-assert_eq() {
-  local label="$1" expected="$2" actual="$3"
-  if [[ "$actual" == "$expected" ]]; then
-    PASS=$((PASS + 1)); echo "  PASS: $label"
-  else
-    FAIL=$((FAIL + 1)); echo "  FAIL: $label (expected '$expected', got '$actual')"
-  fi
-}
-
-assert_contains() {
-  local label="$1" expected="$2" actual="$3"
-  if [[ "$actual" == *"$expected"* ]]; then
-    PASS=$((PASS + 1)); echo "  PASS: $label"
-  else
-    FAIL=$((FAIL + 1)); echo "  FAIL: $label (expected to contain '$expected', got '$actual')"
-  fi
-}
-
-assert_not_contains() {
-  local label="$1" unexpected="$2" actual="$3"
-  if [[ "$actual" != *"$unexpected"* ]]; then
-    PASS=$((PASS + 1)); echo "  PASS: $label"
-  else
-    FAIL=$((FAIL + 1)); echo "  FAIL: $label (expected NOT to contain '$unexpected')"
-  fi
-}
-
-assert_exit() {
-  local label="$1" expected="$2" actual="$3"
-  if [[ "$actual" -eq "$expected" ]]; then
-    PASS=$((PASS + 1)); echo "  PASS: $label"
-  else
-    FAIL=$((FAIL + 1)); echo "  FAIL: $label (expected exit $expected, got $actual)"
-  fi
-}
-
-# ── Test 1: Full dashboard with multiple developers ──────────────────────
-echo "── Test 1: Full dashboard with multiple developers ──"
-
-# Override _now to a fixed time: 2026-03-27T12:00:00Z = 1774836000
-export FORGE_NOW=1774836000
-
-rc=0
-output="$(cmd_dashboard 2>&1)" || rc=$?
-assert_exit "dashboard exits 0" 0 "$rc"
-assert_contains "shows Team Dashboard header" "Team Dashboard" "$output"
-assert_contains "shows devone stats" "devone" "$output"
-assert_contains "shows devtwo stats" "devtwo" "$output"
-assert_contains "shows total summary" "Total:" "$output"
-
-# ── Test 2: Stale issue flagged (forge-bbb >48h old) ────────────────────
-echo ""
-echo "── Test 2: Stale issue flagged ──"
-
-# forge-bbb updated 2026-03-24T10:00:00Z, now is 2026-03-27T12:00:00Z => ~74h
-assert_contains "stale section shown" "Stale assignments" "$output"
-assert_contains "forge-bbb flagged as stale" "forge-bbb" "$output"
-assert_contains "stale issue shows devtwo" "devtwo" "$output"
-
-# ── Test 3: Blocked issue detected (forge-ccc depends on forge-aaa) ─────
-echo ""
-echo "── Test 3: Blocked issue detected ──"
-
-assert_contains "blocked section shown" "Blocked issues" "$output"
-assert_contains "forge-ccc flagged as blocked" "forge-ccc" "$output"
-assert_contains "blocked shows dependency" "forge-aaa" "$output"
-
-# ── Test 4: No issues → "No active issues" ──────────────────────────────
-echo ""
-echo "── Test 4: No issues → clear message ──"
-
-export FORGE_MOCK_EMPTY=1
-rc=0
-output_empty="$(cmd_dashboard 2>&1)" || rc=$?
-assert_exit "empty dashboard exits 0" 0 "$rc"
-assert_contains "shows no active issues" "No active issues" "$output_empty"
-unset FORGE_MOCK_EMPTY
-
-# ── Test 5: Single developer → works correctly ──────────────────────────
-echo ""
-echo "── Test 5: Single developer ──"
-
-export FORGE_MOCK_SINGLE=1
-rc=0
-output_single="$(cmd_dashboard 2>&1)" || rc=$?
-assert_exit "single dev dashboard exits 0" 0 "$rc"
-assert_contains "shows devone" "devone" "$output_single"
-assert_not_contains "no devtwo in single mode" "devtwo" "$output_single"
-unset FORGE_MOCK_SINGLE
-
-# ── Test 6: --format=json → valid JSON ──────────────────────────────────
-echo ""
-echo "── Test 6: --format=json → valid JSON ──"
-
-rc=0
-output_json="$(cmd_dashboard --format=json 2>&1)" || rc=$?
-assert_exit "json format exits 0" 0 "$rc"
-# Check it starts with { and contains expected keys
-assert_contains "json has developers key" "developers" "$output_json"
-assert_contains "json has total key" "total" "$output_json"
-assert_contains "json has stale key" "stale" "$output_json"
-assert_contains "json has blocked key" "blocked" "$output_json"
-
-# ── Results ──────────────────────────────────────────────────────────────
-echo ""
-echo "Results: $PASS passed, $FAIL failed"
-[[ $FAIL -eq 0 ]] && exit 0 || exit 1

package/scripts/lib/beads-migrate-to-dolt.mjs

@@ -1,503 +0,0 @@
-#!/usr/bin/env node
-
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { pathToFileURL } from 'node:url';
-
-const BACKUP_FILES = [
-  'issues.jsonl',
-  'labels.jsonl',
-  'dependencies.jsonl',
-  'comments.jsonl',
-  'events.jsonl',
-  'config.jsonl',
-];
-
-function sanitizePrefix(value) {
-  return value
-    .trim()
-    .toLowerCase()
-    .replaceAll(/[^a-z0-9-]/g, '-')
-    .replaceAll(/-{2,}/g, '-')
-    .replace(/^-/, '')
-    .replace(/-$/, '');
-}
-
-function readJsonl(filePath) {
-  return fs
-    .readFileSync(filePath, 'utf8')
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => JSON.parse(line));
-}
-
-function ensureBackupShape(legacyBackupDir) {
-  if (!fs.existsSync(legacyBackupDir) || !fs.statSync(legacyBackupDir).isDirectory()) {
-    throw new Error(`Legacy backup directory not found: ${legacyBackupDir}`);
-  }
-
-  for (const file of BACKUP_FILES) {
-    const filePath = path.join(legacyBackupDir, file);
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Missing backup file: ${filePath}`);
-    }
-  }
-}
-
-function loadBackupData(backupDir) {
-  ensureBackupShape(backupDir);
-  return {
-    issues: readJsonl(path.join(backupDir, 'issues.jsonl')),
-    labels: readJsonl(path.join(backupDir, 'labels.jsonl')),
-    dependencies: readJsonl(path.join(backupDir, 'dependencies.jsonl')),
-    comments: readJsonl(path.join(backupDir, 'comments.jsonl')),
-    events: readJsonl(path.join(backupDir, 'events.jsonl')),
-    config: readJsonl(path.join(backupDir, 'config.jsonl')),
-  };
-}
-
-function setDifference(left, right) {
-  const rightSet = new Set(right);
-  return left.filter((item) => !rightSet.has(item));
-}
-
-function normalizeRecord(value) {
-  if (Array.isArray(value)) {
-    return value.map((entry) => normalizeRecord(entry));
-  }
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.keys(value)
-        .sort()
-        .map((key) => [key, normalizeRecord(value[key])]),
-    );
-  }
-  return value;
-}
-
-function stableSerializeRecord(record) {
-  return JSON.stringify(normalizeRecord(record));
-}
-
-function arraysEqual(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
-}
-
-function collectParity(data) {
-  return {
-    counts: {
-      issues: data.issues.length,
-      labels: data.labels.length,
-      dependencies: data.dependencies.length,
-      comments: data.comments.length,
-      events: data.events.length,
-      config: data.config.length,
-    },
-    issueIds: data.issues.map((issue) => issue.id).sort(),
-    dependencyEdges: data.dependencies
-      .map((dep) => `${dep.issue_id} ${dep.type} ${dep.depends_on_id}`)
-      .sort(),
-    commentIds: data.comments.map((comment) => comment.id).sort(),
-    configKeys: data.config.map((entry) => entry.key).sort(),
-    issueRecords: data.issues.map((issue) => stableSerializeRecord(issue)).sort(),
-    labelRecords: data.labels.map((label) => stableSerializeRecord(label)).sort(),
-    dependencyRecords: data.dependencies
-      .map((dependency) => stableSerializeRecord(dependency))
-      .sort(),
-    commentRecords: data.comments.map((comment) => stableSerializeRecord(comment)).sort(),
-    eventRecords: data.events.map((event) => stableSerializeRecord(event)).sort(),
-    configRecords: data.config.map((entry) => stableSerializeRecord(entry)).sort(),
-  };
-}
-
-function summarizeParityMismatch(parity) {
-  const parts = [];
-  if (parity.missingIssueIds.length > 0 || parity.extraIssueIds.length > 0) {
-    parts.push('issue ids differ');
-  }
-  if (
-    parity.missingDependencyEdges.length > 0 ||
-    parity.extraDependencyEdges.length > 0
-  ) {
-    parts.push('dependency edges differ');
-  }
-  if (parity.missingCommentIds.length > 0 || parity.extraCommentIds.length > 0) {
-    parts.push('comment ids differ');
-  }
-  if (parity.missingConfigKeys.length > 0 || parity.extraConfigKeys.length > 0) {
-    parts.push('config keys differ');
-  }
-  const recordMismatchMessages = {
-    issues: 'issue records differ',
-    labels: 'label records differ',
-    dependencies: 'dependency records differ',
-    comments: 'comment records differ',
-    events: 'event records differ',
-    config: 'config records differ',
-  };
-  for (const kind of parity.recordMismatches || []) {
-    const message = recordMismatchMessages[kind];
-    if (message && !parts.includes(message)) {
-      parts.push(message);
-    }
-  }
-  if (parts.length === 0) {
-    parts.push('record counts differ');
-  }
-  return parts.join('; ');
-}
-
-export async function verifyMigrationParity({ legacyBackupDir, exportDir }) {
-  const source = collectParity(loadBackupData(legacyBackupDir));
-  const exported = collectParity(loadBackupData(exportDir));
-  const recordMismatches = Object.entries({
-    issues: arraysEqual(source.issueRecords, exported.issueRecords),
-    labels: arraysEqual(source.labelRecords, exported.labelRecords),
-    dependencies: arraysEqual(source.dependencyRecords, exported.dependencyRecords),
-    comments: arraysEqual(source.commentRecords, exported.commentRecords),
-    events: arraysEqual(source.eventRecords, exported.eventRecords),
-    config: arraysEqual(source.configRecords, exported.configRecords),
-  })
-    .filter(([, match]) => !match)
-    .map(([kind]) => kind);
-
-  const parity = {
-    ok:
-      arraysEqual(source.counts, exported.counts) &&
-      arraysEqual(source.issueIds, exported.issueIds) &&
-      arraysEqual(source.dependencyEdges, exported.dependencyEdges) &&
-      arraysEqual(source.commentIds, exported.commentIds) &&
-      arraysEqual(source.configKeys, exported.configKeys) &&
-      recordMismatches.length === 0,
-    counts: source.counts,
-    issueIds: source.issueIds,
-    dependencyEdges: source.dependencyEdges,
-    commentIds: source.commentIds,
-    configKeys: source.configKeys,
-    recordMismatches,
-    missingIssueIds: setDifference(source.issueIds, exported.issueIds),
-    extraIssueIds: setDifference(exported.issueIds, source.issueIds),
-    missingDependencyEdges: setDifference(
-      source.dependencyEdges,
-      exported.dependencyEdges,
-    ),
-    extraDependencyEdges: setDifference(
-      exported.dependencyEdges,
-      source.dependencyEdges,
-    ),
-    missingCommentIds: setDifference(source.commentIds, exported.commentIds),
-    extraCommentIds: setDifference(exported.commentIds, source.commentIds),
-    missingConfigKeys: setDifference(source.configKeys, exported.configKeys),
-    extraConfigKeys: setDifference(exported.configKeys, source.configKeys),
-  };
-
-  return parity;
-}
-
-function snapshotCurrentBeads(projectRoot, snapshotRoot, now = new Date()) {
-  const liveBeadsDir = path.join(projectRoot, '.beads');
-  if (!fs.existsSync(liveBeadsDir)) {
-    throw new Error(`Beads directory not found: ${liveBeadsDir}`);
-  }
-
-  const timestamp = now.toISOString().replaceAll(':', '-');
-  const snapshotDir = path.join(snapshotRoot, timestamp);
-  const snapshotBeadsDir = path.join(snapshotDir, 'current-beads');
-  fs.mkdirSync(snapshotDir, { recursive: true });
-  fs.cpSync(liveBeadsDir, snapshotBeadsDir, { recursive: true });
-  return snapshotDir;
-}
-
-function materializeLegacyBackupDir({ legacyBackupDir, snapshotDir }) {
-  const snapshotBeadsDir = path.join(snapshotDir, 'current-beads');
-  const synthesizedBackupDir = path.join(snapshotDir, 'legacy-backup');
-  fs.mkdirSync(synthesizedBackupDir, { recursive: true });
-
-  for (const file of BACKUP_FILES) {
-    const backupCandidate = path.join(legacyBackupDir, file);
-    const liveCandidate = path.join(snapshotBeadsDir, file);
-    const sourcePath = fs.existsSync(liveCandidate) ? liveCandidate : backupCandidate;
-    if (!fs.existsSync(sourcePath)) {
-      throw new Error(`Missing legacy backup file: ${file}`);
-    }
-    fs.copyFileSync(sourcePath, path.join(synthesizedBackupDir, file));
-  }
-
-  return synthesizedBackupDir;
-}
-
-function applyMigratedBeadsState({ projectRoot, migratedDir }) {
-  const liveBeadsDir = path.join(projectRoot, '.beads');
-  const migratedBeadsDir = path.join(migratedDir, '.beads');
-  const stagedBeadsDir = path.join(projectRoot, `.beads.next-${Date.now()}`);
-
-  if (!fs.existsSync(migratedBeadsDir) || !fs.statSync(migratedBeadsDir).isDirectory()) {
-    throw new Error(`Migrated Beads directory not found: ${migratedBeadsDir}`);
-  }
-
-  fs.rmSync(stagedBeadsDir, { recursive: true, force: true });
-  fs.cpSync(migratedBeadsDir, stagedBeadsDir, { recursive: true });
-  fs.rmSync(liveBeadsDir, { recursive: true, force: true });
-  fs.renameSync(stagedBeadsDir, liveBeadsDir);
-
-  return {
-    liveBeadsDir,
-    migratedBeadsDir,
-  };
-}
-
-function defaultCliPaths(projectRoot) {
-  return {
-    legacyBackupDir: path.join(projectRoot, '.beads', 'backup'),
-    snapshotRoot: path.join(projectRoot, '.beads-migration-snapshots'),
-    migratedDir: path.join(projectRoot, '.beads-migrated'),
-    exportDir: path.join(projectRoot, '.beads-migrated-export'),
-  };
-}
-
-export async function rollbackLegacyBeadsMigration({ projectRoot, snapshotDir }) {
-  const liveBeadsDir = path.join(projectRoot, '.beads');
-  const snapshotBeadsDir = path.join(snapshotDir, 'current-beads');
-
-  if (!fs.existsSync(snapshotBeadsDir)) {
-    throw new Error(`Snapshot payload not found: ${snapshotBeadsDir}`);
-  }
-
-  fs.rmSync(liveBeadsDir, { recursive: true, force: true });
-  fs.cpSync(snapshotBeadsDir, liveBeadsDir, { recursive: true });
-
-  return {
-    restored: true,
-    snapshotDir,
-    liveBeadsDir,
-  };
-}
-
-function resolveBdCommand() {
-  return process.env.BD_CMD || 'bd';
-}
-
-function inferPrefix(projectRoot) {
-  const configPath = path.join(projectRoot, '.beads', 'config.yaml');
-  if (fs.existsSync(configPath)) {
-    const match = /^issue-prefix:\s*(.+)$/m.exec(fs.readFileSync(configPath, 'utf8'));
-    if (match?.[1]) {
-      return sanitizePrefix(match[1]);
-    }
-  }
-  return sanitizePrefix(path.basename(projectRoot) || 'beads');
-}
-
-export function defaultImportBackup({
-  projectRoot,
-  sourceDir,
-  migratedDir,
-  exportDir,
-}) {
-  const bd = resolveBdCommand();
-  fs.mkdirSync(migratedDir, { recursive: true });
-  fs.rmSync(exportDir, { recursive: true, force: true });
-
-  const prefix = inferPrefix(projectRoot);
-  const execOpts = {
-    cwd: migratedDir,
-    encoding: 'utf8',
-    env: {
-      ...process.env,
-      BEADS_DIR: path.join(migratedDir, '.beads'),
-    },
-  };
-
-  execFileSync(
-    bd,
-    ['init', '--force', '--prefix', prefix, '--skip-hooks', '--skip-agents'],
-    execOpts,
-  );
-  execFileSync(bd, ['backup', 'restore', sourceDir], execOpts);
-  execFileSync(bd, ['backup', '--force'], execOpts);
-
-  const exportedBackupDir = path.join(migratedDir, '.beads', 'backup');
-  ensureBackupShape(exportedBackupDir);
-  fs.cpSync(exportedBackupDir, exportDir, { recursive: true });
-
-  return {
-    strategy: 'bd-backup-restore',
-    prefix,
-  };
-}
-
-function writeManifest(manifestPath, payload) {
-  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
-  fs.writeFileSync(manifestPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
-}
-
-export async function runLegacyBeadsMigration(options) {
-  const {
-    projectRoot,
-    legacyBackupDir,
-    snapshotRoot,
-    migratedDir,
-    exportDir,
-    importBackup = defaultImportBackup,
-    now = new Date(),
-  } = options;
-
-  if (!projectRoot || !legacyBackupDir || !snapshotRoot || !migratedDir || !exportDir) {
-    throw new Error('projectRoot, legacyBackupDir, snapshotRoot, migratedDir, and exportDir are required');
-  }
-
-  const manifestPath = path.join(migratedDir, 'migration-manifest.json');
-  if (fs.existsSync(manifestPath)) {
-    return {
-      status: 'skipped',
-      reason: 'already migrated',
-      migratedDir,
-    };
-  }
-
-  const snapshotDir = snapshotCurrentBeads(projectRoot, snapshotRoot, now);
-  const resolvedLegacyBackupDir = materializeLegacyBackupDir({
-    legacyBackupDir,
-    snapshotDir,
-  });
-  let rolledBack = false;
-
-  try {
-    const importResult = await importBackup({
-      projectRoot,
-      sourceDir: resolvedLegacyBackupDir,
-      migratedDir,
-      exportDir,
-      snapshotDir,
-    });
-
-    const parity = await verifyMigrationParity({
-      legacyBackupDir: resolvedLegacyBackupDir,
-      exportDir,
-    });
-
-    if (!parity.ok) {
-      await rollbackLegacyBeadsMigration({ projectRoot, snapshotDir });
-      rolledBack = true;
-
-      const error = new Error(
-        `Parity verification failed: ${summarizeParityMismatch(parity)}`,
-      );
-      error.parity = parity;
-      throw error;
-    }
-
-    const appliedState = applyMigratedBeadsState({
-      projectRoot,
-      migratedDir,
-    });
-
-    writeManifest(manifestPath, {
-      status: 'migrated',
-      createdAt: now.toISOString(),
-      snapshotDir,
-      legacyBackupDir: resolvedLegacyBackupDir,
-      parity,
-      appliedState,
-      importResult: importResult || null,
-    });
-
-    return {
-      status: 'migrated',
-      snapshotDir,
-      migratedDir,
-      exportDir,
-      legacyBackupDir: resolvedLegacyBackupDir,
-      appliedState,
-      parity,
-      importResult: importResult || null,
-    };
-  } catch (error) {
-    if (!rolledBack) {
-      await rollbackLegacyBeadsMigration({ projectRoot, snapshotDir });
-    }
-    throw error;
-  }
-}
-
-export function parseCliArgs(argv, cwd = process.cwd()) {
-  const options = {
-    projectRoot: cwd,
-    ...defaultCliPaths(cwd),
-  };
-  const explicitPathFlags = new Set();
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    switch (arg) {
-      case '--project-root':
-        options.projectRoot = path.resolve(argv[++i]);
-        for (const [key, value] of Object.entries(defaultCliPaths(options.projectRoot))) {
-          if (!explicitPathFlags.has(key)) {
-            options[key] = value;
-          }
-        }
-        break;
-      case '--legacy-backup-dir':
-        options.legacyBackupDir = path.resolve(argv[++i]);
-        explicitPathFlags.add('legacyBackupDir');
-        break;
-      case '--snapshot-root':
-        options.snapshotRoot = path.resolve(argv[++i]);
-        explicitPathFlags.add('snapshotRoot');
-        break;
-      case '--migrated-dir':
-        options.migratedDir = path.resolve(argv[++i]);
-        explicitPathFlags.add('migratedDir');
-        break;
-      case '--export-dir':
-        options.exportDir = path.resolve(argv[++i]);
-        explicitPathFlags.add('exportDir');
-        break;
-      case '-h':
-      case '--help':
-        options.help = true;
-        break;
-      default:
-        throw new Error(`Unknown argument: ${arg}`);
-    }
-  }
-
-  return options;
-}
-
-function printUsage() {
-  console.log(`Usage: beads-migrate-to-dolt [options]
-
-Options:
-  --project-root <path>       Project root containing .beads/
-  --legacy-backup-dir <path>  Legacy JSONL backup directory
-  --snapshot-root <path>      Where rollback snapshots are stored
-  --migrated-dir <path>       Working directory for migrated Beads state
-  --export-dir <path>         Export directory used for parity verification
-  -h, --help                  Show this help message
-`);
-}
-
-async function main() {
-  const options = parseCliArgs(process.argv.slice(2));
-  if (options.help) {
-    printUsage();
-    return;
-  }
-
-  const result = await runLegacyBeadsMigration(options);
-  console.log(JSON.stringify(result, null, 2));
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  main().catch((error) => {
-    console.error(error.message);
-    if (error.parity) {
-      console.error(JSON.stringify(error.parity, null, 2));
-    }
-    process.exitCode = 1;
-  });
-}