@lumenflow/cli 1.0.0 → 1.3.0

package/dist/flow-report.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * Flow Report Generator CLI (WU-1018)
+ *
+ * Generates DORA/SPACE flow reports from telemetry and WU data.
+ *
+ * Usage:
+ *   pnpm flow:report                         # Default: last 7 days, JSON output
+ *   pnpm flow:report --days 30               # Last 30 days
+ *   pnpm flow:report --format table          # Table output
+ *   pnpm flow:report --start 2026-01-01 --end 2026-01-15
+ *
+ * @module flow-report
+ * @see {@link @lumenflow/metrics/flow/generate-flow-report}
+ */
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import fg from 'fast-glob';
+import { parse as parseYaml } from 'yaml';
+import { Command } from 'commander';
+import { generateFlowReport, TELEMETRY_PATHS, } from '@lumenflow/metrics';
+import { die } from '@lumenflow/core/dist/error-handler.js';
+/** Log prefix for console output */
+const LOG_PREFIX = '[flow:report]';
+/** Default report window in days */
+const DEFAULT_DAYS = 7;
+/** Output format options */
+const OUTPUT_FORMATS = {
+    JSON: 'json',
+    TABLE: 'table',
+};
+/** WU directory relative to repo root */
+const WU_DIR = 'docs/04-operations/tasks/wu';
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+    const program = new Command()
+        .name('flow-report')
+        .description('Generate DORA/SPACE flow report from telemetry and WU data')
+        .option('--start <date>', 'Start date (YYYY-MM-DD)')
+        .option('--end <date>', 'End date (YYYY-MM-DD), defaults to today')
+        .option('--days <number>', `Days to report (default: ${DEFAULT_DAYS})`, String(DEFAULT_DAYS))
+        .option('--format <type>', `Output format: json, table (default: json)`, OUTPUT_FORMATS.JSON)
+        .exitOverride();
+    try {
+        program.parse(process.argv);
+        return program.opts();
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === 'commander.helpDisplayed' || error.code === 'commander.version') {
+            process.exit(0);
+        }
+        throw err;
+    }
+}
+/**
+ * Calculate date range from options
+ */
+function calculateDateRange(opts) {
+    const end = opts.end ? new Date(opts.end) : new Date();
+    end.setHours(23, 59, 59, 999);
+    let start;
+    if (opts.start) {
+        start = new Date(opts.start);
+        start.setHours(0, 0, 0, 0);
+    }
+    else {
+        const days = parseInt(opts.days ?? String(DEFAULT_DAYS), 10);
+        start = new Date(end);
+        start.setDate(start.getDate() - days);
+        start.setHours(0, 0, 0, 0);
+    }
+    return { start, end };
+}
+/**
+ * Read NDJSON file and parse events
+ */
+async function readNDJSON(filePath) {
+    if (!existsSync(filePath)) {
+        return [];
+    }
+    const content = await readFile(filePath, { encoding: 'utf-8' });
+    const lines = content.split('\n').filter((line) => line.trim());
+    const events = [];
+    for (const line of lines) {
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch {
+            // Skip invalid JSON lines
+        }
+    }
+    return events;
+}
+/**
+ * Transform raw gate event to GateTelemetryEvent type
+ */
+function transformGateEvent(raw) {
+    if (typeof raw.timestamp !== 'string' ||
+        typeof raw.gate_name !== 'string' ||
+        typeof raw.passed !== 'boolean' ||
+        typeof raw.duration_ms !== 'number') {
+        return null;
+    }
+    return {
+        timestamp: raw.timestamp,
+        wuId: raw.wu_id ?? null,
+        lane: raw.lane ?? null,
+        gateName: raw.gate_name,
+        passed: raw.passed,
+        durationMs: raw.duration_ms,
+    };
+}
+/**
+ * Transform raw LLM event to LLMTelemetryEvent type
+ */
+function transformLLMEvent(raw) {
+    if (typeof raw.timestamp !== 'string' ||
+        typeof raw.event_type !== 'string' ||
+        typeof raw.classification_type !== 'string') {
+        return null;
+    }
+    const eventType = raw.event_type;
+    if (eventType !== 'llm.classification.start' &&
+        eventType !== 'llm.classification.complete' &&
+        eventType !== 'llm.classification.error') {
+        return null;
+    }
+    return {
+        timestamp: raw.timestamp,
+        eventType,
+        classificationType: raw.classification_type,
+        durationMs: raw.duration_ms,
+        tokensUsed: raw.tokens_used,
+        estimatedCostUsd: raw.estimated_cost_usd,
+        confidence: raw.confidence,
+        fallbackUsed: raw.fallback_used,
+        fallbackReason: raw.fallback_reason,
+        errorType: raw.error_type,
+        errorMessage: raw.error_message,
+    };
+}
+/**
+ * Load gate telemetry events from file
+ */
+async function loadGateEvents(baseDir) {
+    const gatesPath = join(baseDir, TELEMETRY_PATHS.GATES);
+    const rawEvents = await readNDJSON(gatesPath);
+    return rawEvents.map(transformGateEvent).filter((e) => e !== null);
+}
+/**
+ * Load LLM telemetry events from file
+ */
+async function loadLLMEvents(baseDir) {
+    const llmPath = join(baseDir, TELEMETRY_PATHS.LLM_CLASSIFICATION);
+    const rawEvents = await readNDJSON(llmPath);
+    return rawEvents.map(transformLLMEvent).filter((e) => e !== null);
+}
+/**
+ * Load completed WUs from YAML files
+ */
+async function loadCompletedWUs(baseDir, start, end) {
+    const wuDir = join(baseDir, WU_DIR);
+    const wuFiles = await fg('WU-*.yaml', { cwd: wuDir, absolute: true });
+    const completedWUs = [];
+    for (const file of wuFiles) {
+        try {
+            const content = await readFile(file, { encoding: 'utf-8' });
+            const wu = parseYaml(content);
+            if (wu.status !== 'done' || !wu.completed_at) {
+                continue;
+            }
+            const completedAt = new Date(wu.completed_at);
+            if (completedAt < start || completedAt > end) {
+                continue;
+            }
+            completedWUs.push({
+                id: wu.id,
+                title: wu.title,
+                lane: wu.lane,
+                status: 'done',
+                claimedAt: wu.claimed_at ? new Date(wu.claimed_at) : undefined,
+                completedAt,
+                cycleTimeHours: calculateCycleTime(wu),
+            });
+        }
+        catch {
+            // Skip invalid WU files
+        }
+    }
+    return completedWUs;
+}
+/**
+ * Calculate cycle time in hours from WU data
+ */
+function calculateCycleTime(wu) {
+    if (!wu.claimed_at || !wu.completed_at) {
+        return undefined;
+    }
+    const claimed = new Date(wu.claimed_at);
+    const completed = new Date(wu.completed_at);
+    const diffMs = completed.getTime() - claimed.getTime();
+    const diffHours = diffMs / (1000 * 60 * 60);
+    return Math.round(diffHours * 10) / 10; // Round to 1 decimal
+}
+/**
+ * Filter events by date range
+ */
+function filterByDateRange(events, start, end) {
+    return events.filter((event) => {
+        const eventDate = new Date(event.timestamp);
+        return eventDate >= start && eventDate <= end;
+    });
+}
+/**
+ * Format report as table output
+ */
+function formatAsTable(report) {
+    const lines = [];
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push(`  FLOW REPORT: ${report.range.start} to ${report.range.end}`);
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+    // Gates section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ GATES                                                       │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push(`│ Pass Rate: ${report.gates.passRate}%  |  Total: ${report.gates.total}  |  P95: ${report.gates.p95}ms │`);
+    lines.push(`│ Passed: ${report.gates.passed}  |  Failed: ${report.gates.failed}`);
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push('│ By Name:                                                    │');
+    for (const [name, stats] of Object.entries(report.gates.byName)) {
+        lines.push(`│   ${name.padEnd(20)} ${stats.passRate}% (${stats.passed}/${stats.total})`);
+    }
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    lines.push('');
+    // WUs section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ WORK UNITS                                                  │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push(`│ Completed: ${report.wus.completed}`);
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    for (const wu of report.wus.list.slice(0, 10)) {
+        lines.push(`│ ${wu.wuId.padEnd(8)} ${wu.completedDate}  ${wu.lane.padEnd(15)} ${wu.title.slice(0, 25)}`);
+    }
+    if (report.wus.list.length > 10) {
+        lines.push(`│ ... and ${report.wus.list.length - 10} more`);
+    }
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    lines.push('');
+    // LLM section
+    lines.push('┌─────────────────────────────────────────────────────────────┐');
+    lines.push('│ LLM CLASSIFICATION                                          │');
+    lines.push('├─────────────────────────────────────────────────────────────┤');
+    lines.push(`│ Total: ${report.llm.totalClassifications}  |  Error Rate: ${report.llm.errorRate}%`);
+    lines.push(`│ Avg Latency: ${report.llm.avgLatencyMs}ms  |  P95: ${report.llm.p95LatencyMs}ms`);
+    lines.push(`│ Tokens: ${report.llm.totalTokens}  |  Cost: $${report.llm.totalCostUsd.toFixed(4)}`);
+    lines.push('└─────────────────────────────────────────────────────────────┘');
+    return lines.join('\n');
+}
+/**
+ * Main function
+ */
+async function main() {
+    const opts = parseArgs();
+    const baseDir = process.cwd();
+    console.log(`${LOG_PREFIX} Generating flow report...`);
+    const { start, end } = calculateDateRange(opts);
+    console.log(`${LOG_PREFIX} Date range: ${start.toISOString().split('T')[0]} to ${end.toISOString().split('T')[0]}`);
+    // Load telemetry and WU data
+    const [gateEvents, llmEvents, completedWUs] = await Promise.all([
+        loadGateEvents(baseDir),
+        loadLLMEvents(baseDir),
+        loadCompletedWUs(baseDir, start, end),
+    ]);
+    // Filter events by date range
+    const filteredGateEvents = filterByDateRange(gateEvents, start, end);
+    const filteredLLMEvents = filterByDateRange(llmEvents, start, end);
+    console.log(`${LOG_PREFIX} Found ${filteredGateEvents.length} gate events`);
+    console.log(`${LOG_PREFIX} Found ${filteredLLMEvents.length} LLM events`);
+    console.log(`${LOG_PREFIX} Found ${completedWUs.length} completed WUs`);
+    // Generate report
+    const input = {
+        gateEvents: filteredGateEvents,
+        llmEvents: filteredLLMEvents,
+        completedWUs,
+        dateRange: {
+            start: start.toISOString().split('T')[0],
+            end: end.toISOString().split('T')[0],
+        },
+    };
+    const report = generateFlowReport(input);
+    // Output report
+    console.log('');
+    if (opts.format === OUTPUT_FORMATS.TABLE) {
+        console.log(formatAsTable(report));
+    }
+    else {
+        console.log(JSON.stringify(report, null, 2));
+    }
+}
+// Guard main() for testability (WU-1366)
+import { fileURLToPath } from 'node:url';
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((err) => {
+        die(`Flow report failed: ${err.message}`);
+    });
+}

package/dist/gates.js

@@ -42,10 +42,11 @@ import { execSync, spawnSync } from 'node:child_process';
 import { closeSync, mkdirSync, openSync, readSync, statSync, writeSync } from 'node:fs';
 import { access } from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { emitGateEvent, getCurrentWU, getCurrentLane } from '@lumenflow/core/dist/telemetry.js';
 import { die } from '@lumenflow/core/dist/error-handler.js';
 import { getChangedLintableFiles, convertToPackageRelativePaths, } from '@lumenflow/core/dist/incremental-lint.js';
-import { buildVitestChangedArgs, isCodeFilePath } from '@lumenflow/core/dist/incremental-test.js';
+import { isCodeFilePath } from '@lumenflow/core/dist/incremental-test.js';
 import { getGitForCwd } from '@lumenflow/core/dist/git-adapter.js';
 import { runCoverageGate, COVERAGE_GATE_MODES } from '@lumenflow/core/dist/coverage-gate.js';
 import { buildGatesLogPath, shouldUseGatesAgentMode, updateGatesLatestSymlink, } from '@lumenflow/core/dist/gates-agent-mode.js';
@@ -55,42 +56,35 @@ import { detectRiskTier, RISK_TIERS, } from '@lumenflow/core/dist/risk-detector.
 // WU-2252: Import invariants runner for first-check validation
 import { runInvariants } from '@lumenflow/core/dist/invariants-runner.js';
 import { Command } from 'commander';
-import { BRANCHES, PACKAGES, PKG_MANAGER, PKG_FLAGS, ESLINT_FLAGS, ESLINT_COMMANDS, ESLINT_DEFAULTS, SCRIPTS, CACHE_STRATEGIES, DIRECTORIES, GATE_NAMES, GATE_COMMANDS, TOOL_PATHS, CLI_MODES, EXIT_CODES, FILE_SYSTEM, } from '@lumenflow/core/dist/wu-constants.js';
+import { BRANCHES, PACKAGES, PKG_MANAGER, PKG_FLAGS, ESLINT_FLAGS, ESLINT_COMMANDS, ESLINT_DEFAULTS, SCRIPTS, CACHE_STRATEGIES, DIRECTORIES, GATE_NAMES, GATE_COMMANDS, TOOL_PATHS, CLI_MODES, EXIT_CODES, FILE_SYSTEM, PRETTIER_ARGS, PRETTIER_FLAGS, } from '@lumenflow/core/dist/wu-constants.js';
 // WU-2457: Add Commander.js for --help support
-// WU-2465: Pre-filter argv to handle pnpm's `--` separator
-// When invoked via `pnpm gates -- --docs-only`, pnpm passes ["--", "--docs-only"]
-// Commander treats `--` as "everything after is positional", causing errors.
-// Solution: Remove standalone `--` from argv before parsing.
-const filteredArgv = process.argv.filter((arg, index, arr) => {
-    // Keep `--` only if it's followed by a non-option (actual positional arg)
-    // Remove it if it's followed by an option (starts with -)
-    if (arg === '--') {
-        const nextArg = arr[index + 1];
-        return nextArg && !nextArg.startsWith('-');
-    }
-    return true;
-});
-const program = new Command()
-    .name('gates')
-    .description('Run quality gates with support for docs-only mode, incremental linting, and tiered testing')
-    .option('--docs-only', 'Run docs-only gates (format, spec-linter, prompts-lint, backlog-sync)')
-    .option('--full-lint', 'Run full lint instead of incremental')
-    .option('--full-tests', 'Run full test suite instead of incremental')
-    .option('--full-coverage', 'Force full test suite and coverage gate (implies --full-tests)')
-    .option('--coverage-mode <mode>', 'Coverage gate mode: "warn" logs warnings, "block" fails gate (default)', 'block')
-    .option('--verbose', 'Stream output in agent mode instead of logging to file')
-    .helpOption('-h, --help', 'Display help for command');
-program.parse(filteredArgv);
-const opts = program.opts();
-// Parse command line arguments (now via Commander)
-const isDocsOnly = opts.docsOnly || false;
-const isFullLint = opts.fullLint || false;
-const isFullTests = opts.fullTests || false;
-// WU-2244: Full coverage flag forces full test suite and coverage gate (deterministic)
-const isFullCoverage = opts.fullCoverage || false;
-// WU-1433: Coverage gate mode (warn or block)
-// WU-2334: Default changed from WARN to BLOCK for TDD enforcement
-const coverageMode = opts.coverageMode || COVERAGE_GATE_MODES.BLOCK;
+function parseGatesArgs(argv = process.argv) {
+    // WU-2465: Pre-filter argv to handle pnpm's `--` separator
+    // When invoked via `pnpm gates -- --docs-only`, pnpm passes ["--", "--docs-only"]
+    // Commander treats `--` as "everything after is positional", causing errors.
+    // Solution: Remove standalone `--` from argv before parsing.
+    const filteredArgv = argv.filter((arg, index, arr) => {
+        // Keep `--` only if it's followed by a non-option (actual positional arg)
+        // Remove it if it's followed by an option (starts with -)
+        if (arg === '--') {
+            const nextArg = arr[index + 1];
+            return nextArg && !nextArg.startsWith('-');
+        }
+        return true;
+    });
+    const program = new Command()
+        .name('gates')
+        .description('Run quality gates with support for docs-only mode, incremental linting, and tiered testing')
+        .option('--docs-only', 'Run docs-only gates (format, spec-linter, prompts-lint, backlog-sync)')
+        .option('--full-lint', 'Run full lint instead of incremental')
+        .option('--full-tests', 'Run full test suite instead of incremental')
+        .option('--full-coverage', 'Force full test suite and coverage gate (implies --full-tests)')
+        .option('--coverage-mode <mode>', 'Coverage gate mode: "warn" logs warnings, "block" fails gate (default)', 'block')
+        .option('--verbose', 'Stream output in agent mode instead of logging to file')
+        .helpOption('-h, --help', 'Display help for command');
+    program.parse(filteredArgv);
+    return program.opts();
+}
 /**
  * Build a pnpm command string
  */
@@ -104,6 +98,60 @@ function pnpmRun(script, ...args) {
     const argsStr = args.length > 0 ? ` ${args.join(' ')}` : '';
     return `${PKG_MANAGER} ${SCRIPTS.RUN} ${script}${argsStr}`;
 }
+export function parsePrettierListOutput(output) {
+    if (!output)
+        return [];
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.replace(/^\[error\]\s*/i, '').trim())
+        .filter((line) => !line.toLowerCase().includes('code style issues found') &&
+        !line.toLowerCase().includes('all matched files use prettier') &&
+        !line.toLowerCase().includes('checking formatting'));
+}
+export function buildPrettierWriteCommand(files) {
+    const quotedFiles = files.map((file) => `"${file}"`).join(' ');
+    const base = pnpmCmd(SCRIPTS.PRETTIER, PRETTIER_FLAGS.WRITE);
+    return quotedFiles ? `${base} ${quotedFiles}` : base;
+}
+export function formatFormatCheckGuidance(files) {
+    if (!files.length)
+        return [];
+    const command = buildPrettierWriteCommand(files);
+    return [
+        '',
+        '❌ format:check failed',
+        'Fix with:',
+        `  ${command}`,
+        '',
+        'Affected files:',
+        ...files.map((file) => `  - ${file}`),
+        '',
+    ];
+}
+function collectPrettierListDifferent(cwd) {
+    const cmd = pnpmCmd(SCRIPTS.PRETTIER, PRETTIER_ARGS.LIST_DIFFERENT, '.');
+    const result = spawnSync(cmd, [], {
+        shell: true,
+        cwd,
+        encoding: FILE_SYSTEM.ENCODING,
+    });
+    const output = `${result.stdout || ''}\n${result.stderr || ''}`;
+    return parsePrettierListOutput(output);
+}
+function emitFormatCheckGuidance({ agentLog, useAgentMode, }) {
+    const files = collectPrettierListDifferent(process.cwd());
+    if (!files.length)
+        return;
+    const lines = formatFormatCheckGuidance(files);
+    const logLine = useAgentMode && agentLog
+        ? (line) => writeSync(agentLog.logFd, `${line}\n`)
+        : (line) => console.log(line);
+    for (const line of lines) {
+        logLine(line);
+    }
+}
 /**
  * Build a pnpm --filter command string
  */
@@ -184,6 +232,15 @@ async function runIncrementalLint({ agentLog, } = {}) {
         }
         writeSync(agentLog.logFd, `${line}\n`);
     };
+    // WU-1006: Skip incremental lint if apps/web doesn't exist (repo-agnostic)
+    const webDir = path.join(process.cwd(), DIRECTORIES.APPS_WEB);
+    try {
+        await access(webDir);
+    }
+    catch {
+        logLine('\n> ESLint (incremental) skipped (apps/web not present)\n');
+        return { ok: true, duration: Date.now() - start, fileCount: 0 };
+    }
     try {
         // Check if we're on main branch
         const git = getGitForCwd();
@@ -298,15 +355,11 @@ async function runChangedTests({ agentLog, } = {}) {
             const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
             return { ...result, duration: Date.now() - start, isIncremental: false };
         }
-        logLine('\n> Vitest (changed: tools project)\n');
-        const toolsArgs = ['--project', 'tools', ...buildVitestChangedArgs()];
-        const toolsResult = run(pnpmCmd('vitest', ...toolsArgs), { agentLog });
-        if (!toolsResult.ok) {
-            return { ...toolsResult, duration: Date.now() - start, isIncremental: true };
-        }
-        logLine('\n> Vitest (changed: turbo --affected)\n');
-        const result = run(pnpmCmd('turbo', 'run', 'test:changed', '--affected'), { agentLog });
-        return { ...result, duration: Date.now() - start, isIncremental: true };
+        // WU-1006: Use turbo for tests (repo-agnostic)
+        // Previously used --project tools and test:changed which don't exist in all repos
+        logLine('\n> Running tests (turbo run test)\n');
+        const result = run(pnpmCmd('turbo', 'run', 'test'), { agentLog });
+        return { ...result, duration: Date.now() - start, isIncremental: false };
     }
     catch (error) {
         console.error('⚠️  Changed tests failed, falling back to full suite:', error.message);
@@ -359,6 +412,15 @@ async function runSafetyCriticalTests({ agentLog, } = {}) {
         }
         writeSync(agentLog.logFd, `${line}\n`);
     };
+    // WU-1006: Skip safety-critical tests if apps/web doesn't exist (repo-agnostic)
+    const webDir = path.join(process.cwd(), DIRECTORIES.APPS_WEB);
+    try {
+        await access(webDir);
+    }
+    catch {
+        logLine('\n> Safety-critical tests skipped (apps/web not present)\n');
+        return { ok: true, duration: Date.now() - start, testCount: 0 };
+    }
     try {
         logLine('\n> Safety-critical tests (always run)\n');
         logLine(`Test files: ${SAFETY_CRITICAL_TEST_FILES.length} files\n`);
@@ -466,6 +528,16 @@ const agentLog = useAgentMode ? createAgentLogContext({ wuId: wu_id, lane }) : n
 // Main execution
 // eslint-disable-next-line sonarjs/cognitive-complexity -- Pre-existing: main() orchestrates multi-step gate workflow
 async function main() {
+    const opts = parseGatesArgs();
+    // Parse command line arguments (now via Commander)
+    const isDocsOnly = opts.docsOnly || false;
+    const isFullLint = opts.fullLint || false;
+    const isFullTests = opts.fullTests || false;
+    // WU-2244: Full coverage flag forces full test suite and coverage gate (deterministic)
+    const isFullCoverage = opts.fullCoverage || false;
+    // WU-1433: Coverage gate mode (warn or block)
+    // WU-2334: Default changed from WARN to BLOCK for TDD enforcement
+    const coverageMode = opts.coverageMode || COVERAGE_GATE_MODES.BLOCK;
     if (useAgentMode) {
         console.log(`🧾 gates (agent mode): output -> ${agentLog.logPath} (use --verbose for streaming)\n`);
     }
@@ -656,6 +728,9 @@ async function main() {
                 }
                 continue;
             }
+            if (gate.name === GATE_NAMES.FORMAT_CHECK) {
+                emitFormatCheckGuidance({ agentLog, useAgentMode });
+            }
             if (useAgentMode) {
                 const tail = readLogTail(agentLog.logPath);
                 console.error(`\n❌ ${gate.name} failed (agent mode). Log: ${agentLog.logPath}\n`);
@@ -678,7 +753,9 @@ async function main() {
     }
     process.exit(EXIT_CODES.SUCCESS);
 }
-main().catch((error) => {
-    console.error('Gates failed:', error);
-    process.exit(EXIT_CODES.ERROR);
-});
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch((error) => {
+        console.error('Gates failed:', error);
+        process.exit(EXIT_CODES.ERROR);
+    });
+}