@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.1

package/dist/runtime/headless.js

@@ -1,548 +0,0 @@
-/**
- * Headless mode runner for `pugi --print "<brief>"`.
- *
- * Design intent (CEO directive "нужно тестирование по кругу"):
- *
- *  Pugi must be drivable non-interactively by the upstream tool, Codex, CI
- *  runners, Docker images, and any agent that can spawn a subprocess.
- *  The Ink REPL is the human-facing surface; headless mode is the
- *  machine-facing surface. One round-trip = one engine turn = one
- *  `--print` invocation.
- *
- * Output contract (mirrors `claude --print --json`):
- *
- *  Stdout — ONLY NDJSON event lines (one JSON object per line):
- *    {"type":"session.start", sessionId, cwd, timestamp}
- *    {"type":"turn.start",   turnIndex, timestamp}
- *    {"type":"tool.call",    callId, tool, args, timestamp}
- *    {"type":"tool.result",  callId, status, summary, timestamp}
- *    {"type":"text.delta",   content, timestamp}
- *    {"type":"thinking.delta",content, blockId, timestamp}
- *    {"type":"turn.end",     turnIndex, usage, timestamp}
- *    {"type":"session.end",  status, totalTokensIn, totalTokensOut,
- *                             durationMs, filesChanged, timestamp}
- *    {"type":"error",        kind, message, exit_code}
- *
- *  Stderr — human-readable status + error details (never NDJSON).
- *
- * Stdout vs stderr discipline lets a caller pipe cleanly:
- *
- *    pugi --print "..." --json 2>/dev/null | jq .
- *
- * Exit codes:
- *
- *  0 session.end emitted with status=done (or "complete")
- *  1 hard error (auth, network, server crash, engine_unavailable)
- *  2 turn-limit / budget exhausted without completion
- *
- * Reuses the existing `NativePugiEngineAdapter` (the same path the
- * REPL drives) — the only difference is the output sink: instead of
- * mounting Ink, we subscribe to the adapter's `streamEmitter` and
- * forward each typed event as NDJSON.
- */
-import { resolve as resolvePath } from 'node:path';
-import { existsSync, statSync } from 'node:fs';
-import { AnvilEngineLoopClient } from '../core/engine/anvil-client.js';
-import { NativePugiEngineAdapter } from '../core/engine/native-pugi.js';
-import { defaultNonInteractiveMcpPrompt } from '../tools/mcp-tool.js';
-import { loadMcpRegistry } from '../core/mcp/registry.js';
-import { openSession, recordCommandStarted, recordCommandCompleted, } from '../core/session.js';
-import { buildRuntimeConfig, loadRuntimeConfig, } from '@pugi/sdk';
-import { resolveActiveCredential } from '../core/credentials.js';
-/**
- * NDJSON event emitter. One JSON object per line on stdout. Never emits
- * partial lines — every event ends with `\n` so a caller piping into
- * `jq -c` can parse incrementally. Stderr is reserved for human prose
- * (errors, traces) so the operator's `2>/dev/null` filter keeps stdout
- * pure machine-readable.
- */
-class NdjsonEventSink {
-    stdoutWrite;
-    constructor(stdoutWrite) {
-        this.stdoutWrite = stdoutWrite;
-    }
-    emit(event) {
-        // Stamp every event with `timestamp` if the caller did not supply
-        // one. ISO-8601 with millisecond precision is the agreed contract
-        // (per spec); a downstream timeline UI can sort lexicographically.
-        const stamped = {
-            ...event,
-            timestamp: event.timestamp ?? new Date().toISOString(),
-        };
-        this.stdoutWrite(`${JSON.stringify(stamped)}\n`);
-    }
-}
-/**
- * Human-readable text sink. Used when `--print` runs WITHOUT `--json`
- * (a human watching the pipe). Tool calls show as `> tool(args)`,
- * results as `< ok|fail: summary`, text deltas as raw prose chunks.
- * Status frames are demoted to stderr so the conversation flow on
- * stdout stays clean.
- */
-class TextEventSink {
-    stdoutWrite;
-    stderrWrite;
-    constructor(stdoutWrite, stderrWrite) {
-        this.stdoutWrite = stdoutWrite;
-        this.stderrWrite = stderrWrite;
-    }
-    emit(event) {
-        switch (event.type) {
-            case 'session.start':
-                this.stderrWrite(`pugi headless: session ${event.sessionId} cwd=${event.cwd}\n`);
-                return;
-            case 'turn.start':
-                this.stderrWrite(`> turn ${event.turnIndex}\n`);
-                return;
-            case 'tool.call':
-                this.stderrWrite(`> ${event.tool}(${truncate(JSON.stringify(event.args), 80)})\n`);
-                return;
-            case 'tool.result':
-                this.stderrWrite(`< ${event.status === 'success' ? 'ok' : 'fail'}: ${truncate(String(event.summary ?? ''), 120)}\n`);
-                return;
-            case 'text.delta':
-                // Bare prose on stdout — this IS the answer.
-                this.stdoutWrite(String(event.content ?? ''));
-                return;
-            case 'thinking.delta':
-                // Thinking is informational; surface on stderr so stdout is the
-                // visible answer only. Operators who want thinking pipe stderr.
-                this.stderrWrite(`[think] ${truncate(String(event.content ?? ''), 200)}\n`);
-                return;
-            case 'turn.end':
-                this.stderrWrite(`< turn ${event.turnIndex} end\n`);
-                return;
-            case 'session.end':
-                // Newline separator so the final stdout text and stderr summary
-                // do not run together when both are tee'd to the same terminal.
-                this.stdoutWrite('\n');
-                this.stderrWrite(`pugi headless: ${event.status} · ${event.totalTokensIn ?? 0}+${event.totalTokensOut ?? 0} tokens · ${event.durationMs}ms\n`);
-                return;
-            case 'error':
-                this.stderrWrite(`pugi headless: error (${event.kind}) ${event.message}\n`);
-                return;
-            default:
-                return;
-        }
-    }
-}
-function truncate(s, max) {
-    return s.length <= max ? s : `${s.slice(0, max - 3)}...`;
-}
-/**
- * Auto-init the workspace if `.pugi/` is missing. Per beta.13 the
- * scaffold is silent — headless callers (CI, agents) drop into fresh
- * cwds all the time and the first run must not require a manual
- * `pugi init` step. We DO surface a stderr breadcrumb so the operator
- * sees what changed on disk.
- */
-async function ensurePugiInitializedWithLog(cwd, stderrWrite) {
-    const pugiDir = resolvePath(cwd, '.pugi');
-    if (existsSync(pugiDir) && statSync(pugiDir).isDirectory())
-        return;
-    // Late-import so the CLI bootstrap cost stays minimal — scaffold is
-    // only loaded when the auto-init path actually fires.
-    const { scaffoldPugiWorkspace } = await import('./cli.js');
-    stderrWrite(`pugi headless: scaffolding .pugi/ in ${cwd}\n`);
-    await scaffoldPugiWorkspace({
-        cwd,
-        noDefaults: true,
-        log: (line) => stderrWrite(`[init] ${line}`),
-    });
-}
-/**
- * Resolve the runtime credential. Headless mode REQUIRES a token — we
- * cannot launch a device flow without a TTY to drop a browser into. A
- * missing credential is a hard error with exit 1.
- */
-function resolveHeadlessCredential() {
-    const credential = resolveActiveCredential();
-    if (credential) {
-        return buildRuntimeConfig({
-            apiUrl: credential.apiUrl,
-            apiKey: credential.apiKey,
-        });
-    }
-    // Fall through to env-only config (CI sets PUGI_API_KEY directly).
-    return loadRuntimeConfig();
-}
-/**
- * Headless entry point. Returns the desired process exit code.
- *
- *  0 — done / completed
- *  1 — hard error (auth, engine_unavailable, transport crash)
- *  2 — turn-limit / budget exhausted
- *
- * Caller (cli.ts) sets `process.exitCode`; we do NOT call `process.exit`
- * directly so a future REPL-embedded `/print` slash can reuse the same
- * function in-process without tearing down the host.
- */
-export async function runHeadlessPrint(opts) {
-    const cwd = resolvePath(opts.cwd);
-    // Default writers route to the real process streams; tests inject
-    // closures so `node:test`'s binary-IPC hijack of `process.stdout`
-    // does not collide with the captured NDJSON output.
-    const stdoutWrite = opts.stdoutWrite ?? ((chunk) => process.stdout.write(chunk));
-    const stderrWrite = opts.stderrWrite ?? ((chunk) => process.stderr.write(chunk));
-    const sink = opts.json
-        ? new NdjsonEventSink(stdoutWrite)
-        : new TextEventSink(stdoutWrite, stderrWrite);
-    const startedAt = Date.now();
-    // 1. Auto-init the workspace if needed.
-    try {
-        await ensurePugiInitializedWithLog(cwd, stderrWrite);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        sink.emit({
-            type: 'error',
-            kind: 'init_failed',
-            message: `failed to scaffold .pugi/: ${message}`,
-            exit_code: 1,
-        });
-        return 1;
-    }
-    // 2. Resolve the credential. Headless cannot interactively log in.
-    //   When a test factory is injected we still build a config (the
-    //   factory ignores it) so the type contract stays narrow.
-    let config;
-    if (opts.engineClientFactory) {
-        config =
-            loadRuntimeConfig() ??
-                buildRuntimeConfig({
-                    apiUrl: 'http://127.0.0.1:1/headless-fixture',
-                    apiKey: 'pugi_headless_fixture',
-                });
-    }
-    else {
-        config = resolveHeadlessCredential();
-    }
-    if (!config) {
-        sink.emit({
-            type: 'error',
-            kind: 'auth_missing',
-            message: 'No Pugi credential. Run `pugi login` or set PUGI_API_KEY before invoking `pugi --print` (headless mode cannot launch device flow without a TTY).',
-            exit_code: 1,
-        });
-        return 1;
-    }
-    // 3. Open a session. The session id flows through every event line
-    //   so external tooling can correlate the headless run with its
-    //   server-side trace.
-    const session = openSession(cwd);
-    if (opts.sessionIdOverride && opts.sessionIdOverride.length > 0) {
-        // Override is informational — we cannot reassign `session.id`
-        // safely (it threads through `recordToolCall`), but we surface
-        // the requested id alongside the resolved one so the caller can
-        // join its own logs.
-        sink.emit({
-            type: 'session.start',
-            sessionId: session.id,
-            requestedSessionId: opts.sessionIdOverride,
-            cwd,
-            ...(opts.workspace ? { workspace: opts.workspace } : {}),
-        });
-    }
-    else {
-        sink.emit({
-            type: 'session.start',
-            sessionId: session.id,
-            cwd,
-            ...(opts.workspace ? { workspace: opts.workspace } : {}),
-        });
-    }
-    recordCommandStarted(session, 'print');
-    // 4. Construct the engine client + adapter. The factory seam exists
-    //   purely for tests; production always builds `AnvilEngineLoopClient`.
-    const client = opts.engineClientFactory
-        ? opts.engineClientFactory(config)
-        : new AnvilEngineLoopClient(config);
-    // MCP registry: best-effort load. Headless mode honors the workspace
-    // MCP config the same way the REPL does — a failed registry should
-    // not kill the run, but the operator deserves a stderr breadcrumb.
-    let mcpRegistry;
-    try {
-        mcpRegistry = await loadMcpRegistry(cwd);
-    }
-    catch (error) {
-        stderrWrite(`pugi headless: MCP registry load failed — ${error.message}. Continuing without MCP.\n`);
-        mcpRegistry = undefined;
-    }
-    const adapter = new NativePugiEngineAdapter({
-        client,
-        session,
-        // --no-tools maps to suppressing fetch + search opt-ins. The
-        // tool-bridge schema is determined per-kind; we cannot dial it to
-        // zero from the adapter constructor today (that requires a
-        // tool-bridge plumbing change). For β1 we honor --no-tools by
-        // refusing the engine path entirely when set AND the kind is one
-        // that requires tools to be useful — see the gate below.
-        allowFetch: !opts.noTools,
-        allowSearch: !opts.noTools,
-        ...(mcpRegistry ? { mcpRegistry } : {}),
-        mcpPrompt: defaultNonInteractiveMcpPrompt,
-        interactive: false,
-    });
-    // 5. Subscribe to the adapter's typed stream emitter and forward
-    //   every event as one NDJSON line. The emitter is the canonical
-    //   source for tool / text / thinking deltas — the async-iterable
-    //   `adapter.run()` collapses richer types into lossy `status` for
-    //   legacy SDK consumers, which we deliberately bypass here.
-    let turnIndex = 0;
-    let currentTurnTokensIn = 0;
-    let currentTurnTokensOut = 0;
-    let totalTokens = 0;
-    const filesChanged = new Set();
-    const sawTurnStart = false; // tracked via emitter
-    const handleStreamEvent = (event) => {
-        switch (event.type) {
-            case 'status': {
-                // Status frames carry adapter lifecycle prose. Most are noise
-                // for an NDJSON consumer; the structurally meaningful ones we
-                // synthesize into typed events below. A few worth surfacing:
-                // `turn N: requesting model` → emit turn.start.
-                const m = /^turn (\d+): requesting model/.exec(event.message);
-                if (m) {
-                    turnIndex = Number(m[1]);
-                    sink.emit({ type: 'turn.start', turnIndex, timestamp: event.timestamp });
-                    return;
-                }
-                const t = /^turn (\d+): model returned final text/.exec(event.message);
-                if (t) {
-                    // Closing turn.end is emitted on result yield below so we
-                    // have token usage to attach. Skip the synthetic close here.
-                    return;
-                }
-                // All other status frames are diagnostic — surface as a
-                // structured `status` event so consumers can opt in.
-                sink.emit({
-                    type: 'status',
-                    message: event.message,
-                    timestamp: event.timestamp,
-                });
-                return;
-            }
-            case 'tool.start':
-                sink.emit({
-                    type: 'tool.call',
-                    callId: event.callId,
-                    tool: event.name,
-                    args: safeJsonParse(event.arguments),
-                    timestamp: event.timestamp,
-                });
-                return;
-            case 'tool.end':
-                sink.emit({
-                    type: 'tool.result',
-                    callId: event.callId,
-                    status: event.ok ? 'success' : 'error',
-                    summary: event.summary,
-                    timestamp: event.timestamp,
-                });
-                return;
-            case 'tool.delta':
-                // Pass through as a partial chunk so a long-running bash can
-                // surface progress.
-                sink.emit({
-                    type: 'tool.delta',
-                    callId: event.callId,
-                    chunk: event.chunk,
-                    timestamp: event.timestamp,
-                });
-                return;
-            case 'text.delta':
-                sink.emit({
-                    type: 'text.delta',
-                    content: event.chunk,
-                    timestamp: event.timestamp,
-                });
-                return;
-            case 'thinking.start':
-                sink.emit({
-                    type: 'thinking.start',
-                    blockId: event.blockId,
-                    timestamp: event.timestamp,
-                });
-                return;
-            case 'thinking.delta':
-                sink.emit({
-                    type: 'thinking.delta',
-                    blockId: event.blockId,
-                    content: event.chunk,
-                    timestamp: event.timestamp,
-                });
-                return;
-            case 'thinking.end':
-                sink.emit({
-                    type: 'thinking.end',
-                    blockId: event.blockId,
-                    timestamp: event.timestamp,
-                });
-                return;
-            default:
-                return;
-        }
-    };
-    adapter.streamEmitter.on('event', handleStreamEvent);
-    // 6. Optional timeout — wire an AbortController so the engine loop
-    //   bails cleanly. The signal also feeds the tool-bridge cancellation
-    //   gate so long-running bash / network tools tear down.
-    const abort = new AbortController();
-    let timeoutHandle = null;
-    if (opts.timeoutSeconds && opts.timeoutSeconds > 0) {
-        timeoutHandle = setTimeout(() => {
-            abort.abort();
-            stderrWrite(`pugi headless: timeout after ${opts.timeoutSeconds}s — aborting engine\n`);
-        }, opts.timeoutSeconds * 1000);
-        // Don't keep node alive purely for the timeout — the engine path
-        // already holds the event loop via the AnvilEngineLoopClient fetch.
-        timeoutHandle.unref?.();
-    }
-    // 7. Drive the adapter to terminal. We iterate the (lossier)
-    //   EngineEvent stream solely to learn when the result frame lands;
-    //   every richer event already flew through `streamEmitter` above.
-    const kind = opts.kind ?? 'code';
-    const taskId = `print-${Date.now()}`;
-    // PUGI-VERIFY-GATE: `needs_verification` is the new fourth
-    // status the engine adapter surfaces when a `completed` loop ran
-    // no verification command. Widen the local var to match the
-    // engine result schema.
-    let finalStatus = 'failed';
-    let finalSummary = '';
-    let resultRisks = [];
-    let eventRefs = [];
-    try {
-        const events = adapter.run({
-            id: taskId,
-            kind,
-            prompt: opts.prompt,
-            workspaceRoot: cwd,
-            allowedPaths: [cwd],
-            deniedPaths: [],
-            artifacts: [],
-            permissionMode: 'auto',
-            ...(opts.maxTurns ? { budget: { tokens: opts.maxTurns * 16384 } } : {}),
-        }, { sessionId: session.id, signal: abort.signal });
-        for await (const ev of events) {
-            if (ev.type === 'result') {
-                finalStatus = ev.result.status;
-                finalSummary = ev.result.summary;
-                resultRisks = ev.result.risks;
-                eventRefs = ev.result.eventRefs;
-                for (const f of ev.result.filesChanged)
-                    filesChanged.add(f);
-            }
-            // status frames already routed through the emitter — ignore here.
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        sink.emit({
-            type: 'error',
-            kind: 'engine_crash',
-            message,
-            exit_code: 1,
-        });
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-        adapter.streamEmitter.off('event', handleStreamEvent);
-        recordCommandCompleted(session, 'print', 'error');
-        return 1;
-    }
-    if (timeoutHandle)
-        clearTimeout(timeoutHandle);
-    adapter.streamEmitter.off('event', handleStreamEvent);
-    if (mcpRegistry) {
-        await mcpRegistry.shutdown().catch(() => {
-            /* swallow — best-effort */
-        });
-    }
-    // 8. Pull headline metrics out of the result's eventRefs (adapter
-    //   echoes `tokens=N` / `turns=N` / `tool_calls=N` / `outcome=...`).
-    const metrics = parseRefs(eventRefs);
-    totalTokens = metrics.tokens;
-    currentTurnTokensIn;
-    currentTurnTokensOut;
-    sawTurnStart; // silence TS6133
-    // Emit one closing turn.end so consumers always see a paired turn
-    // start/end. We use the final turn index reported by the adapter.
-    sink.emit({
-        type: 'turn.end',
-        turnIndex: metrics.turns || turnIndex || 1,
-        usage: {
-            // Engine outcome carries a single cumulative `tokens` figure; we
-            // split it 50/50 as a best-effort estimate until the SDK splits
-            // input/output. Documented as approximate so consumers do not
-            // treat the breakdown as authoritative.
-            tokensIn: Math.floor(totalTokens / 2),
-            tokensOut: Math.ceil(totalTokens / 2),
-        },
-    });
-    // 9. Emit session.end. Exit code policy per spec:
-    //   - done                → 0
-    //   - needs_verification  → 2 (PUGI-VERIFY-GATE)
-    //   - blocked + outcome=budget_exhausted → 2
-    //   - blocked + any other reason → 2 (turn limit, tool refused — both
-    //                                      count as "did not complete")
-    //   - failed              → 1
-    const exitCode = finalStatus === 'done'
-        ? 0
-        : finalStatus === 'blocked' || finalStatus === 'needs_verification'
-            ? 2
-            : 1;
-    const durationMs = Date.now() - startedAt;
-    sink.emit({
-        type: 'session.end',
-        sessionId: session.id,
-        status: finalStatus,
-        outcome: metrics.outcome,
-        totalTokensIn: Math.floor(totalTokens / 2),
-        totalTokensOut: Math.ceil(totalTokens / 2),
-        totalToolCalls: metrics.toolCalls,
-        totalTurns: metrics.turns,
-        durationMs,
-        filesChanged: Array.from(filesChanged).sort(),
-        risks: resultRisks,
-        finalText: finalSummary,
-    });
-    recordCommandCompleted(session, 'print', exitCode === 0 ? 'success' : 'error');
-    return exitCode;
-}
-/**
- * Best-effort JSON parse for tool arguments. Engine emits the raw
- * argument string the model produced; if it is malformed we keep the
- * raw string so the consumer can still see what the model sent.
- */
-function safeJsonParse(s) {
-    try {
-        return JSON.parse(s);
-    }
-    catch {
-        return s;
-    }
-}
-/**
- * Parse the `eventRefs` echo the adapter attaches to its result frame.
- * Mirrors `parseEventRefs` in `cli.ts` — kept local so the headless
- * module has no circular import on the runtime entry.
- */
-function parseRefs(refs) {
-    const out = { toolCalls: 0, turns: 0, tokens: 0, outcome: null };
-    for (const ref of refs) {
-        const idx = ref.indexOf('=');
-        if (idx <= 0)
-            continue;
-        const key = ref.slice(0, idx);
-        const value = ref.slice(idx + 1);
-        if (key === 'tool_calls')
-            out.toolCalls = Number(value) || 0;
-        else if (key === 'turns')
-            out.turns = Number(value) || 0;
-        else if (key === 'tokens')
-            out.tokens = Number(value) || 0;
-        else if (key === 'outcome')
-            out.outcome = value || null;
-    }
-    return out;
-}
-//# sourceMappingURL=headless.js.map

package/dist/runtime/load-hooks-or-exit.js

@@ -1,71 +0,0 @@
-/**
- * Fail-closed hook registry loader.
- *
- * r2 (triple-review P2): the previous fail-open path silently
- * disabled BLOCK rules when `.pugi/hooks.json` parsed badly. This module
- * is the dedicated load path used by the engine command dispatch — it
- * distinguishes three states:
- *
- *  (a) No hooks file present → returns `undefined` (acceptable; the
- *      operator has no hooks configured).
- *  (b) Hooks file present + parses + loads → returns the live registry.
- *  (c) Hooks file present + parse/load FAILS → emits a fatal message
- *      and signals `refusedExit`. The caller (cli.ts) is expected to
- *      honor that by calling `process.exit(1)`. `PUGI_HOOKS_BYPASS=1`
- *      is the explicit operator-typed escape hatch.
- *
- * Extracted from `cli.ts` purely so the fail-closed contract is unit-
- * testable without spawning a subprocess. The shape returned is a
- * discriminated union so tests can assert each branch directly.
- *
- * Brand voice: no forbidden words. ASCII only. No emoji.
- */
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { HookRegistry } from '../core/hooks.js';
-export async function loadHookRegistryOrExit(opts) {
-    const stderrWrite = opts.deps?.stderrWrite ??
-        ((msg) => {
-            process.stderr.write(msg);
-        });
-    const env = opts.deps?.env ?? process.env;
-    const projectHooksPath = resolve(opts.workspaceRoot, '.pugi', 'hooks.json');
-    const pugiHomeRoot = env.PUGI_HOME ?? resolve(homedir(), '.pugi');
-    const userHooksPath = resolve(pugiHomeRoot, 'hooks.json');
-    const presentHookFiles = [projectHooksPath, userHooksPath].filter((p) => existsSync(p));
-    if (presentHookFiles.length === 0) {
-        return { kind: 'no-hooks-file', hooks: undefined };
-    }
-    try {
-        const reg = new HookRegistry({
-            workspaceRoot: opts.workspaceRoot,
-            session: opts.session,
-        });
-        await reg.load();
-        return { kind: 'loaded', hooks: reg };
-    }
-    catch (error) {
-        const msg = error.message;
-        stderrWrite(`pugi ${opts.label}: hook configuration present but failed to load — refusing to run.\n` +
-            ` files checked: ${presentHookFiles.join(', ')}\n` +
-            ` error: ${msg}\n` +
-            ` fix: validate the JSON or remove the file; or set PUGI_HOOKS_BYPASS=1 to override (NOT RECOMMENDED — disables block rules).\n`);
-        if (env.PUGI_HOOKS_BYPASS === '1') {
-            stderrWrite(`pugi ${opts.label}: PUGI_HOOKS_BYPASS=1 — continuing WITHOUT hooks despite parse failure.\n`);
-            return {
-                kind: 'parse-failure-bypassed',
-                hooks: undefined,
-                filesChecked: presentHookFiles,
-                error: msg,
-            };
-        }
-        return {
-            kind: 'parse-failure-refused',
-            filesChecked: presentHookFiles,
-            error: msg,
-            hooks: undefined,
-        };
-    }
-}
-//# sourceMappingURL=load-hooks-or-exit.js.map