@stupify/cli 0.0.3 → 0.0.5

package/dist/stupify.js

@@ -1,21 +1,18 @@
 #!/usr/bin/env node
+import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { auditCandidates, countPromptTokens, findingsAuditRequest, runFindingsAudit, scoutBatch, scoutSemChanges, } from "./analysis.js";
-import { batchDiff } from "./batcher.js";
-import { candidateContexts } from "./candidate-context.js";
-import { enabledChecks } from "./checks.js";
+import { countPromptTokens, runSearch, searchRequest } from "./analysis.js";
+import { searchChecks } from "./checks.js";
 import { parseCommand } from "./command.js";
-import { MODEL_REGISTRY } from "./constants.js";
 import { counterScoutTargets } from "./counter-scout.js";
-import { readDiffFromStdin } from "./diff.js";
-import { runExperiment } from "./experiment.js";
-import { netDiffForCommit, netDiffForRecentCommits, netDiffFromStdin, netDiffSince, } from "./git.js";
-import { loadLocalModels } from "./model.js";
-import { emptyContextPack, entityContextsFromChanges, repomixContextPack } from "./repomix-provider.js";
-import { helpText, renderReport } from "./render.js";
+import { runDoctor } from "./doctor.js";
+import { runHookCommand } from "./hooks.js";
+import { firstRunModelBootstrap, loadLocalModel } from "./model.js";
+import { entityContextsFromChanges, emptyContextPack, repomixContextPack, repomixSearchConfig } from "./repomix-provider.js";
+import { helpText, renderSearchRun } from "./render.js";
+import { effectiveMaxCandidates, effectiveMaxSearchInputTokens, effectiveRepomixConfig, effectiveSearchChecks, loadSearchProfile, } from "./search-profile.js";
 import { semChangeSetForCommand } from "./sem-provider.js";
-import { createTracer, trace } from "./trace.js";
-const SEM_SCOUT_CHUNK_SIZE = 200;
+import { createTracer } from "./trace.js";
 export async function main(argv = process.argv.slice(2)) {
     const startedAt = Date.now();
     try {
@@ -24,16 +21,22 @@ export async function main(argv = process.argv.slice(2)) {
             console.log(helpText());
             return 0;
         }
-        if (command.kind === "experiment") {
-            const outputDir = await runExperiment(command.configPath);
-            console.log(`Experiment results written to ${outputDir}`);
+        if (command.kind === "hook") {
+            console.log(await runHookCommand(command.action));
             return 0;
         }
-        const checks = enabledChecks(command.checkIds);
-        const report = command.engine === "sem"
-            ? await runSemEngine(command, checks, startedAt)
-            : await runRawDiffEngine(command, checks, startedAt);
-        console.log(renderReport(report, command));
+        if (command.kind === "doctor") {
+            const result = await runDoctor();
+            console.log(result.text);
+            return result.exitCode;
+        }
+        if (command.kind === "bench-search") {
+            const { runSearchBench } = await import("./search-bench.js");
+            console.log(await runSearchBench(command.configPath));
+            return 0;
+        }
+        const run = await runSearchCommand(command, startedAt);
+        console.log(renderSearchRun(run, command));
         return 0;
     }
     catch (error) {
@@ -41,347 +44,195 @@ export async function main(argv = process.argv.slice(2)) {
         return 1;
     }
 }
-async function runRawDiffEngine(command, checks, startedAt) {
-    const { value: diff, ms: diffMs } = await trace.trace("net.diff", () => netDiffForCommand(command));
-    printRunPlan(command, diff, checks.map((check) => check.id));
-    const { value: models, ms: modelMs } = await trace.trace("model.load", () => loadLocalModels(command.model));
-    const { scoutModel, auditModel } = models;
-    const batches = batchDiff(diff.text);
-    const { value: candidatePointers, ms: searchMs } = await trace.trace("search.total", async () => {
-        const pointers = [];
-        for (const batch of batches) {
-            const { value: candidates } = await trace.trace("search.batch", () => scoutBatch(scoutModel, batch, checks, diff.label), { fields: { batch: batch.id } });
-            pointers.push(...candidates);
-        }
-        return pointers;
-    });
-    const contexts = candidateContexts(batches, candidatePointers);
-    const auditedContexts = contexts;
-    const { value: result, ms: auditMs } = await trace.trace("audit.candidates", () => auditCandidates(auditModel, diff, auditedContexts, checks), { fields: { candidates: auditedContexts.length } });
-    return {
-        run: {
-            mode: command.kind,
-            engine: command.engine,
-            auditContext: command.auditContext,
-            auditPrompt: command.auditPrompt,
-            modelId: command.model,
-            checkIds: checks.map((check) => check.id),
-            sourceId: diff.id,
-            label: diff.label,
-            stats: diff.stats,
-            batchesScanned: batches.length,
-            candidateCount: new Set(candidatePointers).size,
-            entitiesScanned: 0,
-            auditedCandidateCount: auditedContexts.length,
-            scoutModelCalls: batches.length,
-            auditModelCalls: auditedContexts.length > 0 ? 1 : 0,
-            warnings: [],
-            timingsMs: {
-                diff: diffMs,
-                modelLoad: modelMs,
-                search: searchMs,
-                audit: auditMs,
-                total: Date.now() - startedAt,
-            },
-            debugTargets: command.debugTargets ? [] : undefined,
-        },
-        result,
-    };
-}
-async function runSemEngine(command, checks, startedAt) {
-    const traceEvents = [];
+export async function runSearchCommand(command, startedAt) {
     const t = createTracer({
+        writeLine: () => undefined,
         onEvent: (event) => {
-            traceEvents.push(event);
-            debugSemTrace(command, event);
+            const parts = [`trace ${event.name}`, `${event.ms}ms`];
+            if (event.count !== undefined)
+                parts.push(`count=${event.count}`);
+            if (event.detail)
+                parts.push(event.detail);
+            console.error(parts.join(" "));
         },
     });
-    const { value: changeSet, ms: diffMs } = await t.trace("entity.diff", () => semChangeSetForCommand(command), {
+    const profile = await loadSearchProfile(command.searchProfilePath);
+    const checks = profile ? effectiveSearchChecks(command.checkIds, profile) : searchChecks(command.checkIds);
+    const patternIds = checks.map((check) => check.id);
+    const maxCandidates = effectiveMaxCandidates(command.maxCandidates, profile);
+    const maxSearchInputTokens = effectiveMaxSearchInputTokens(command.maxSearchInputTokens, profile);
+    const { value: changeSet } = await t.trace("entity.diff", () => semChangeSetForCommand(command), {
         count: (v) => v.summary.total,
         detail: (v) => `${v.summary.fileCount} files`,
     });
-    printSemRunPlan(command, changeSet, checks.map((check) => check.id));
-    const { value: models, ms: modelMs } = await t.trace("model.load", () => loadLocalModels(command.model), {
-        count: () => 2,
-        detail: () => "scout+audit",
-    });
-    const { scoutModel, auditModel } = models;
     try {
-        const candidateBatches = chunkSemChangeSet(changeSet);
-        const { value: candidates, ms: searchMs } = await t.trace("scout.total", async () => candidateBatches.length === 0
-            ? []
-            : command.scout === "counter"
-                ? counterScoutTargets(changeSet, checks, command.maxCandidates)
-                : scoutSemBatches(scoutModel, candidateBatches, checks, command, traceEvents, t), {
-            count: (v) => v.length,
-            detail: () => `${command.scout} scout ${candidateBatches.length} batches`,
-        });
-        const { value: contexts, ms: contextMs } = await t.trace("context.select", async () => entityContextsFromChanges(candidates, changeSet.changes), {
-            fields: { candidates: candidates.length },
-            count: (v) => v.length,
-            detail: (v) => `${new Set(v.map((context) => context.filePath).filter(Boolean)).size} files`,
-        });
-        const auditBatches = chunkSemContexts(contexts, command.auditBatchSize);
-        const { value: result, ms: auditMs } = await t.trace("audit.total", () => findingsAuditBatches(auditModel, changeSet, auditBatches, checks, traceEvents, t, command), {
-            count: (v) => v.findings.length,
-            detail: (v) => `${auditBatches.length} batches targets=${v.stats.totalTargets} clean=${v.stats.clean} uncertain=${v.stats.uncertain} invalid=${v.stats.invalid}`,
-        });
-        return {
-            run: {
-                mode: command.kind,
-                engine: command.engine,
-                auditContext: command.auditContext,
-                auditPrompt: command.auditPrompt,
-                modelId: command.model,
-                checkIds: checks.map((check) => check.id),
-                sourceId: changeSet.id,
-                label: changeSet.label,
+        printRunPlan(command, changeSet.summary.fileCount, changeSet.summary.total, patternIds);
+        const candidates = counterScoutTargets(changeSet, checks, maxCandidates);
+        const contexts = entityContextsFromChanges(candidates, changeSet.changes);
+        const targetsByPattern = countTargetsByPattern(contexts);
+        const targetsPreview = previewTargets(contexts);
+        if (contexts.length === 0) {
+            return {
+                schemaVersion: "search.v1",
+                mode: "search",
+                source: command.source,
+                model: { id: command.model },
+                patterns: patternIds,
                 stats: {
+                    elapsedMs: Date.now() - startedAt,
+                    modelCalls: 0,
+                    skipped: true,
+                    skipReason: "no_candidates",
                     filesChanged: changeSet.summary.fileCount,
-                    additions: changeSet.summary.added,
-                    deletions: changeSet.summary.deleted,
+                    entitiesScanned: changeSet.summary.total,
+                    candidates: 0,
+                    searchTargets: 0,
+                    repomixFiles: 0,
+                    repomixTokens: 0,
+                    profileId: profile?.id,
+                    targetsByPattern,
+                    targetsPreview,
                 },
-                batchesScanned: 0,
-                entitiesScanned: changeSet.summary.total,
-                candidateCount: candidates.length,
-                targetsByCheck: countTargetsByCheck(candidates),
-                auditedCandidateCount: contexts.length,
-                scoutModelCalls: traceEvents.filter((event) => event.name === "scout.batch").length,
-                auditModelCalls: result.auditModelCalls,
-                timingsMs: {
-                    diff: diffMs,
-                    modelLoad: modelMs,
-                    search: searchMs,
-                    audit: auditMs + contextMs,
-                    total: Date.now() - startedAt,
+                matches: [],
+            };
+        }
+        const baseRepomixConfig = effectiveRepomixConfig(repomixSearchConfig(), profile);
+        const initialPack = profile?.context === "sem"
+            ? emptyContextPack()
+            : await t.trace("context.pack", () => repomixContextPack(changeSet.contextCwd, contexts, changeSet.changes, baseRepomixConfig), {
+                count: (v) => v.filePaths.length,
+                detail: (v) => `${v.totalTokens} tokens`,
+            }).then((result) => result.value);
+        const packedFiles = new Set(initialPack.filePaths);
+        const searchContexts = profile?.context === "sem"
+            ? contexts
+            : contexts.filter((context) => context.filePath && packedFiles.has(context.filePath));
+        if (searchContexts.length === 0) {
+            return {
+                schemaVersion: "search.v1",
+                mode: "search",
+                source: command.source,
+                model: { id: command.model },
+                patterns: patternIds,
+                stats: {
+                    elapsedMs: Date.now() - startedAt,
+                    modelCalls: 0,
+                    skipped: true,
+                    skipReason: "no_candidates",
+                    filesChanged: changeSet.summary.fileCount,
+                    entitiesScanned: changeSet.summary.total,
+                    candidates: contexts.length,
+                    searchTargets: 0,
+                    repomixFiles: initialPack.filePaths.length,
+                    repomixTokens: initialPack.totalTokens,
+                    repomixConfig: initialPack.config,
+                    profileId: profile?.id,
+                    targetsByPattern,
+                    targetsPreview,
                 },
-                warnings: [],
-                auditStats: result.stats,
-                debugTargets: command.debugTargets ? debugTargetsFromContexts(contexts, changeSet.label) : undefined,
-                traceEvents,
+                matches: [],
+            };
+        }
+        const pack = profile?.context === "sem" || searchContexts.length === contexts.length
+            ? initialPack
+            : await repomixContextPack(changeSet.contextCwd, searchContexts, changeSet.changes, baseRepomixConfig);
+        const modelPath = await firstRunModelBootstrap(command.model);
+        const model = await loadLocalModel(modelPath, command.model, "scout");
+        const request = buildSearchRequest(changeSet, searchContexts, pack, checks, profile, command.includeCounterReasonInPrompt);
+        const inputTokens = await countPromptTokens(model, request.prompt);
+        if (inputTokens > maxSearchInputTokens) {
+            return {
+                schemaVersion: "search.v1",
+                mode: "search",
+                source: command.source,
+                model: { id: command.model },
+                patterns: patternIds,
+                stats: {
+                    elapsedMs: Date.now() - startedAt,
+                    modelCalls: 0,
+                    inputTokens,
+                    inputTokenCap: maxSearchInputTokens,
+                    skipped: true,
+                    skipReason: "input_too_large",
+                    filesChanged: changeSet.summary.fileCount,
+                    entitiesScanned: changeSet.summary.total,
+                    candidates: contexts.length,
+                    searchTargets: searchContexts.length,
+                    repomixFiles: pack.filePaths.length,
+                    repomixTokens: pack.totalTokens,
+                    repomixConfig: pack.config,
+                    profileId: profile?.id,
+                    targetsByPattern: countTargetsByPattern(searchContexts),
+                    targetsPreview: previewTargets(searchContexts),
+                },
+                matches: [],
+            };
+        }
+        const { value: matches } = await t.trace("search.model", () => runSearch(model, request), { count: (v) => v.length });
+        return {
+            schemaVersion: "search.v1",
+            mode: "search",
+            source: command.source,
+            model: { id: command.model },
+            patterns: patternIds,
+            stats: {
+                elapsedMs: Date.now() - startedAt,
+                modelCalls: 1,
+                inputTokens,
+                inputTokenCap: maxSearchInputTokens,
+                filesChanged: changeSet.summary.fileCount,
+                entitiesScanned: changeSet.summary.total,
+                candidates: contexts.length,
+                searchTargets: searchContexts.length,
+                repomixFiles: pack.filePaths.length,
+                repomixTokens: pack.totalTokens,
+                repomixConfig: pack.config,
+                profileId: profile?.id,
+                targetsByPattern: countTargetsByPattern(searchContexts),
+                targetsPreview: previewTargets(searchContexts),
             },
-            result,
+            matches,
         };
     }
     finally {
         await changeSet.cleanup();
     }
 }
-async function findingsAuditBatches(model, changeSet, batches, checks, traceEvents, t, command) {
-    const findings = [];
-    const stats = { totalTargets: 0, finding: 0, clean: 0, uncertain: 0, invalid: 0 };
-    const limiter = new ConcurrencyLimiter(command.auditConcurrency);
-    for (const [index, batch] of batches.entries()) {
-        const result = await findingsAuditBatch(model, changeSet, batch, checks, traceEvents, command, limiter, `${index + 1}/${batches.length}`);
-        findings.push(...result.findings);
-        stats.totalTargets += result.stats.totalTargets;
-        stats.finding += result.stats.finding;
-        stats.clean += result.stats.clean;
-        stats.uncertain += result.stats.uncertain;
-        stats.invalid += result.stats.invalid;
-    }
-    return {
-        findings,
-        summary: findings.length === 0
-            ? "No clear judgment-offload signal found."
-            : `${findings.length} finding review${findings.length === 1 ? "" : "s"} accepted.`,
-        stats,
-        auditModelCalls: traceEvents.filter((event) => event.name === "audit.batch").length,
-    };
-}
-async function findingsAuditBatch(model, changeSet, batch, checks, traceEvents, command, limiter, batchLabel) {
-    const { value: pack, ms: contextMs } = await trace.trace("context.pack", () => command.auditContext === "none"
-        ? Promise.resolve(emptyContextPack())
-        : repomixContextPack(changeSet.contextCwd, batch, changeSet.changes), { fields: { candidates: batch.length } });
-    const request = findingsAuditRequest(changeSet, batch, pack, checks, command.auditPrompt);
-    const inputTokens = await countPromptTokens(model, request.prompt);
-    const contextEvent = {
-        name: "context.pack",
-        ms: contextMs,
-        count: pack.filePaths.length,
-        detail: `batch=${batchLabel} input_tokens=${inputTokens} pack_tokens=${pack.totalTokens} chars=${pack.totalCharacters}`,
-    };
-    traceEvents.push(contextEvent);
-    debugSemTrace(command, contextEvent);
-    if (inputTokens > command.maxAuditInputTokens) {
-        if (batch.length <= 1) {
-            throw new Error(`Findings audit input has ${inputTokens} tokens, above max ${command.maxAuditInputTokens}.`);
-        }
-        const splitAt = Math.ceil(batch.length / 2);
-        const splitEvent = {
-            name: "audit.split",
-            ms: 0,
-            count: batch.length,
-            detail: `batch=${batchLabel} input_tokens=${inputTokens} max=${command.maxAuditInputTokens}`,
-        };
-        traceEvents.push(splitEvent);
-        debugSemTrace(command, splitEvent);
-        const [left, right] = await Promise.all([
-            findingsAuditBatch(model, changeSet, batch.slice(0, splitAt), checks, traceEvents, command, limiter, `${batchLabel}.1`),
-            findingsAuditBatch(model, changeSet, batch.slice(splitAt), checks, traceEvents, command, limiter, `${batchLabel}.2`),
-        ]);
-        return combineAuditResults(left, right);
-    }
-    const { value: result, ms: auditMs } = await trace.trace("audit.batch", () => limiter.run(() => runFindingsAudit(model, changeSet, batch, pack, checks, request)), { fields: { candidates: batch.length } });
-    const event = {
-        name: "audit.batch",
-        ms: auditMs,
-        count: result.findings.length,
-        detail: `batch=${batchLabel} candidates=${batch.length} input_tokens=${inputTokens} targets=${result.stats.totalTargets} clean=${result.stats.clean} uncertain=${result.stats.uncertain} invalid=${result.stats.invalid}`,
-    };
-    traceEvents.push(event);
-    debugSemTrace(command, event);
-    return result;
+function buildSearchRequest(changeSet, contexts, pack, patterns, profile, includeCounterReasonInPrompt) {
+    return searchRequest({
+        changeSet,
+        contexts,
+        pack,
+        patterns,
+        includeCounterReasonInPrompt: profile?.includeCounterReasonInPrompt ?? includeCounterReasonInPrompt,
+    });
 }
-function combineAuditResults(left, right) {
-    const findings = [...left.findings, ...right.findings];
-    return {
-        findings,
-        summary: findings.length === 0
-            ? "No clear judgment-offload signal found."
-            : `${findings.length} finding review${findings.length === 1 ? "" : "s"} accepted.`,
-        stats: {
-            totalTargets: left.stats.totalTargets + right.stats.totalTargets,
-            finding: left.stats.finding + right.stats.finding,
-            clean: left.stats.clean + right.stats.clean,
-            uncertain: left.stats.uncertain + right.stats.uncertain,
-            invalid: left.stats.invalid + right.stats.invalid,
-        },
-    };
+function printRunPlan(command, filesChanged, entitiesScanned, patternIds) {
+    if (command.json)
+        return;
+    console.error("🧙 stupify 🪄");
+    console.error(`Mode: search (${command.source})`);
+    console.error(`Sem: ${filesChanged} files, ${entitiesScanned} changed entities`);
+    console.error(`Patterns: ${patternIds.join(", ")}`);
 }
-function countTargetsByCheck(candidates) {
+function countTargetsByPattern(contexts) {
     const counts = {};
-    for (const candidate of candidates) {
-        counts[candidate.checkId] = (counts[candidate.checkId] ?? 0) + 1;
-    }
+    for (const context of contexts)
+        counts[context.checkId] = (counts[context.checkId] ?? 0) + 1;
     return counts;
 }
-function debugTargetsFromContexts(contexts, sourceLabel) {
+function previewTargets(contexts) {
     return contexts.map((context) => ({
         targetId: context.targetId,
-        checkId: context.checkId,
-        entityId: context.entityId,
-        entityKind: context.entityKind,
-        changeKind: context.changeKind,
-        scoutReason: context.reason,
-        sourceLabel,
+        patternId: context.checkId,
+        entityKind: context.entityKind || undefined,
+        sourceKind: context.filePath ? pathKind(context.filePath) : undefined,
     }));
 }
-class ConcurrencyLimiter {
-    max;
-    active = 0;
-    queue = [];
-    constructor(max) {
-        this.max = max;
-    }
-    async run(task) {
-        if (this.active >= this.max) {
-            await new Promise((resolve) => this.queue.push(resolve));
-        }
-        this.active += 1;
-        try {
-            return await task();
-        }
-        finally {
-            this.active -= 1;
-            this.queue.shift()?.();
-        }
-    }
-}
-async function scoutSemBatches(model, batches, checks, command, traceEvents, t) {
-    const candidates = [];
-    const seen = new Set();
-    const targetsByCheck = new Map();
-    const maxTargetsPerCheck = 6;
-    for (const [index, batch] of batches.entries()) {
-        if (candidates.length >= command.maxCandidates)
-            break;
-        const remaining = command.maxCandidates - candidates.length;
-        const { value: batchCandidates } = await t.trace("scout.batch", async () => scoutSemChanges(model, batch, checks, remaining), {
-            fields: { entities: batch.changes.length },
-            count: (v) => v.length,
-            detail: (v) => `batch=${index + 1}/${batches.length} entities=${batch.changes.length} remaining=${remaining}`,
-        });
-        for (const candidate of batchCandidates) {
-            const key = `${candidate.entityId}\u0000${candidate.checkId}`;
-            if (seen.has(key))
-                continue;
-            const checkCount = targetsByCheck.get(candidate.checkId) ?? 0;
-            if (checkCount >= maxTargetsPerCheck)
-                continue;
-            seen.add(key);
-            targetsByCheck.set(candidate.checkId, checkCount + 1);
-            candidates.push({
-                ...candidate,
-                targetId: `t${String(candidates.length + 1).padStart(3, "0")}`,
-            });
-            if (candidates.length >= command.maxCandidates)
-                break;
-        }
-    }
-    return candidates;
-}
-function debugSemTrace(command, event) {
-    if (!command.debugSem)
-        return;
-    const parts = [`trace ${event.name}`, `${event.ms}ms`];
-    if (event.count !== undefined)
-        parts.push(`count=${event.count}`);
-    if (event.detail)
-        parts.push(event.detail);
-    console.error(parts.join(" "));
-}
-function chunkSemChangeSet(changeSet) {
-    const chunks = [];
-    for (let index = 0; index < changeSet.changes.length; index += SEM_SCOUT_CHUNK_SIZE) {
-        const changes = changeSet.changes.slice(index, index + SEM_SCOUT_CHUNK_SIZE);
-        chunks.push({
-            ...changeSet,
-            label: `${changeSet.label} batch ${chunks.length + 1}`,
-            changes,
-            summary: {
-                ...changeSet.summary,
-                fileCount: new Set(changes.map((change) => change.filePath)).size,
-                total: changes.length,
-            },
-        });
-    }
-    return chunks;
-}
-function chunkSemContexts(contexts, chunkSize) {
-    const chunks = [];
-    for (let index = 0; index < contexts.length; index += chunkSize) {
-        chunks.push(contexts.slice(index, index + chunkSize));
-    }
-    return chunks;
-}
-function printRunPlan(command, diff, checkIds) {
-    if (command.json)
-        return;
-    console.error("🧙 stupify 🪄");
-    console.error(`Window: ${diff.label}`);
-    console.error(`Diff: ${diff.stats.filesChanged} files changed, ${diff.stats.additions} added, ${diff.stats.deletions} deleted`);
-    console.error(`Model: ${MODEL_REGISTRY[command.model].name}`);
-    console.error(`Checks: ${checkIds.join(", ")}`);
-}
-function printSemRunPlan(command, changeSet, checkIds) {
-    if (command.json)
-        return;
-    console.error("🧙 stupify 🪄");
-    console.error(`Window: ${changeSet.label}`);
-    console.error(`Sem: ${changeSet.summary.fileCount} files, ${changeSet.summary.total} changed entities`);
-    console.error(`Model: ${MODEL_REGISTRY[command.model].name}`);
-    console.error(`Checks: ${checkIds.join(", ")}`);
-}
-async function netDiffForCommand(command) {
-    if (command.kind === "since")
-        return netDiffSince(command.since);
-    if (command.kind === "stdin")
-        return netDiffFromStdin(await readDiffFromStdin());
-    if (command.kind === "commit")
-        return netDiffForCommit(command.commit);
-    return netDiffForRecentCommits(command.count);
+function pathKind(filePath) {
+    const ext = filePath.split(".").pop();
+    return ext && ext !== filePath ? ext : "unknown";
 }
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
     process.exitCode = await main();
 }