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

package/dist/runtime/commands/model.js

@@ -1,237 +0,0 @@
-/**
- * `/model` / `pugi model` — BT 8 (the upstream tool parity).
- *
- * Lists OR selects the active model. The MVP uses a hardcoded
- * tier-aware registry mirrored from the per-model price ladder in
- * `core/repl/model-pricing.ts` so the operator sees the same models
- * the cost meter understands. A future iteration can swap the static
- * registry for an admin-api `GET /api/pugi/models` round-trip — the
- * runner contract (`MODEL_REGISTRY` + `runModelCommand`) is the right
- * shape for that swap because the renderer + writer paths are
- * decoupled from the source.
- *
- * Persistence lands at `<workspaceRoot>/.pugi/settings.json` under a
- * top-level `model.slug` key. We extend the file directly with a
- * round-trip read-merge-write so we do not invalidate the existing
- * Zod schema in `core/settings.ts` — the schema there reads only the
- * keys it knows about, leaving `model.*` as a forward-compatible
- * passthrough.
- *
- * Tier gating mirrors the four-tier pricing (Free / Founder $20 /
- * Builder $99 / Team $199). The slugs here are the same ones the
- * cost meter renders, so the operator can always swap to a cheaper
- * fallback if they hit a quota wall.
- */
-import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-/**
- * Tier rank for comparing "user tier >= model.minTier". The order is
- * Free < Founder < Builder < Team. The cabinet's pricing module owns
- * the canonical pricing copy; the CLI just needs the rank to filter
- * the menu.
- */
-export const TIER_RANK = Object.freeze({
-    free: 0,
-    founder: 1,
-    builder: 2,
-    team: 3,
-});
-/**
- * Static model registry. Sources:
- *  - Anthropic Claude family (claude-opus, claude-sonnet, claude-haiku):
- *    list prices.
- *  - OpenAI (gpt-4o, gpt-4o-mini, o3, o3-mini): list prices.
- *  - Mistral (mistral-large, mistral-small): list prices.
- *
- * Family fallbacks (`claude-opus-4-7` falling back onto the
- * `claude-opus-` family entry in `model-pricing.ts`) live in the price
- * ladder, not here — the registry is the canonical selectable surface.
- */
-export const MODEL_REGISTRY = Object.freeze([
-    // Free tier — cheap defaults so the meter never blanks on a fresh signup.
-    {
-        slug: 'claude-haiku-4-5',
-        label: 'Claude Haiku 4.5',
-        minTier: 'free',
-        inputUsdPerM: 0.8,
-        outputUsdPerM: 4.0,
-        summary: 'Fast + cheap. Default for quick dispatches and the free tier.',
-    },
-    {
-        slug: 'gpt-4o-mini',
-        label: 'GPT-4o mini',
-        minTier: 'free',
-        inputUsdPerM: 0.15,
-        outputUsdPerM: 0.6,
-        summary: 'Cheapest mainstream model. Good for short turns.',
-    },
-    // Founder ($20) — mid-tier mainstream models.
-    {
-        slug: 'claude-sonnet-4-6',
-        label: 'Claude Sonnet 4.6',
-        minTier: 'founder',
-        inputUsdPerM: 3.0,
-        outputUsdPerM: 15.0,
-        summary: 'Balanced for code dispatch. Strong tool use.',
-    },
-    {
-        slug: 'gpt-4o',
-        label: 'GPT-4o',
-        minTier: 'founder',
-        inputUsdPerM: 2.5,
-        outputUsdPerM: 10.0,
-        summary: 'Multimodal-capable. Good general-purpose flagship.',
-    },
-    // Builder ($99) — mid-strong reasoning + Mistral options.
-    {
-        slug: 'o3-mini',
-        label: 'OpenAI o3-mini',
-        minTier: 'builder',
-        inputUsdPerM: 1.1,
-        outputUsdPerM: 4.4,
-        summary: 'Cheaper reasoning. Good for plan/review turns.',
-    },
-    {
-        slug: 'mistral-large',
-        label: 'Mistral Large',
-        minTier: 'builder',
-        inputUsdPerM: 2.0,
-        outputUsdPerM: 6.0,
-        summary: 'Strong open-weight reasoning. EU-hosted option.',
-    },
-    // Team ($199) — top-tier reasoning.
-    {
-        slug: 'claude-opus-4-7',
-        label: 'Claude Opus 4.7',
-        minTier: 'team',
-        inputUsdPerM: 15.0,
-        outputUsdPerM: 75.0,
-        summary: 'Flagship reasoning. Best for hard refactors + multi-file edits.',
-    },
-    {
-        slug: 'o3',
-        label: 'OpenAI o3',
-        minTier: 'team',
-        inputUsdPerM: 10.0,
-        outputUsdPerM: 40.0,
-        summary: 'Strong reasoning + deliberation. Good for plan/critique loops.',
-    },
-]);
-/** Returns the registry filtered to models the operator's tier can use. */
-export function modelsForTier(tier) {
-    const rank = TIER_RANK[tier];
-    return MODEL_REGISTRY.filter((m) => TIER_RANK[m.minTier] <= rank);
-}
-/** Looks up a descriptor by slug. */
-export function lookupModel(slug) {
-    return MODEL_REGISTRY.find((m) => m.slug === slug);
-}
-/**
- * Entry point for the slash + the top-level CLI. Side effects:
- *  - command.slug undefined: prints the tier-gated menu + current row.
- *  - command.slug set + unknown: prints a one-line error.
- *  - command.slug set + above tier: prints a tier-lock message.
- *  - command.slug set + valid + reachable: merges `model.slug` into
- *    <workspaceRoot>/.pugi/settings.json and prints a confirmation.
- *
- * The function never throws on a missing settings file — it creates
- * `.pugi/` + writes a fresh object. Read failures (malformed JSON) are
- * surfaced as a system line + the runner refuses to write so the
- * operator can recover by hand.
- */
-export async function runModelCommand(command, ctx) {
-    const tier = ctx.tier ?? 'team';
-    const fs = ctx.fs ?? defaultFs(ctx.workspaceRoot);
-    if (command.slug === undefined) {
-        return renderMenu(ctx, fs, tier);
-    }
-    const descriptor = lookupModel(command.slug);
-    if (!descriptor) {
-        ctx.writeOutput(`/model: unknown slug '${command.slug}'. Run /model to see the menu.`);
-        return { command: 'model', status: 'unknown_slug', reason: command.slug };
-    }
-    if (TIER_RANK[descriptor.minTier] > TIER_RANK[tier]) {
-        ctx.writeOutput(`/model: '${descriptor.slug}' requires the ${descriptor.minTier} tier. `
-            + `You are on '${tier}'. Run /model to see available options.`);
-        return { command: 'model', status: 'tier_locked', slug: descriptor.slug };
-    }
-    // Merge + persist. Any IO error becomes a one-line warning; the
-    // session continues without crashing.
-    try {
-        const current = fs.readSettings() ?? {};
-        const nextSettings = {
-            ...current,
-            model: {
-                ...(typeof current.model === 'object' && current.model !== null
-                    ? current.model
-                    : {}),
-                slug: descriptor.slug,
-            },
-        };
-        fs.writeSettings(nextSettings);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        ctx.writeOutput(`/model: persist failed — ${message}. Selection is session-only.`);
-    }
-    ctx.writeOutput(`Model set to '${descriptor.label}' (${descriptor.slug}). ` +
-        `Cost: $${descriptor.inputUsdPerM.toFixed(2)}/M in, $${descriptor.outputUsdPerM.toFixed(2)}/M out.`);
-    return { command: 'model', status: 'selected', slug: descriptor.slug };
-}
-function renderMenu(ctx, fs, tier) {
-    const current = readCurrentSlug(fs);
-    const visible = modelsForTier(tier);
-    ctx.writeOutput(`Current model: ${current ?? '(unset, default)'}. Your tier: ${tier}.`);
-    ctx.writeOutput('');
-    ctx.writeOutput('Available models:');
-    for (const m of visible) {
-        const mark = current === m.slug ? '*' : ' ';
-        const price = `$${m.inputUsdPerM.toFixed(2)}/M in, $${m.outputUsdPerM.toFixed(2)}/M out`;
-        ctx.writeOutput(` ${mark} ${m.slug.padEnd(22)} ${m.label.padEnd(22)} ${price}`);
-        ctx.writeOutput(`   ${m.summary}`);
-    }
-    const locked = MODEL_REGISTRY.filter((m) => TIER_RANK[m.minTier] > TIER_RANK[tier]);
-    if (locked.length > 0) {
-        ctx.writeOutput('');
-        ctx.writeOutput(`Higher-tier models (upgrade required):`);
-        for (const m of locked) {
-            ctx.writeOutput(` - ${m.slug} (${m.minTier})`);
-        }
-    }
-    ctx.writeOutput('');
-    ctx.writeOutput('Switch with `/model <slug>`. The choice persists to .pugi/settings.json.');
-    return { command: 'model', status: 'listed', slug: current ?? undefined };
-}
-function readCurrentSlug(fs) {
-    try {
-        const data = fs.readSettings();
-        if (!data || typeof data !== 'object')
-            return null;
-        const model = data.model;
-        if (!model || typeof model !== 'object')
-            return null;
-        const slug = model.slug;
-        return typeof slug === 'string' && slug.length > 0 ? slug : null;
-    }
-    catch {
-        return null;
-    }
-}
-function defaultFs(workspaceRoot) {
-    const path = resolve(workspaceRoot, '.pugi/settings.json');
-    return {
-        readSettings: () => {
-            if (!existsSync(path))
-                return null;
-            const raw = readFileSync(path, 'utf8');
-            if (raw.trim().length === 0)
-                return null;
-            return JSON.parse(raw);
-        },
-        writeSettings: (next) => {
-            mkdirSync(dirname(path), { recursive: true });
-            writeFileSync(path, JSON.stringify(next, null, 2) + '\n', 'utf8');
-        },
-    };
-}
-//# sourceMappingURL=model.js.map

package/dist/runtime/commands/onboarding.js

@@ -1,275 +0,0 @@
-/**
- * — `pugi onboarding` first-run wizard runner.
- *
- * Six-step interactive walk that lands a new operator on a configured
- * Pugi:
- *
- *  1. Welcome + auth status    — suggests `pugi login` when no creds
- *  2. Default permission mode  — plan / ask / allow / bypass (L6)
- *  3. Output style             — default / terse / explanatory /
- *                                 russian-formal / casual (L18)
- *  4. MCP server pointer       — link to `pugi mcp add` (L13)
- *  5. Telemetry consent        — off / anonymous / community
- *  6. Recap card + marker touch — `pugi doctor` next-step hint
- *
- * Two execution modes:
- *
- *  - **Interactive (TTY + no `--non-interactive` flag)** — mount the
- *    Ink wizard (`tui/onboarding-wizard.tsx`) and await the
- *    operator's verdict step by step. The wizard returns a structured
- *    `OnboardingVerdict` describing each chosen value (or "skip"
- *    when the operator pressed Enter on the current-value row).
- *
- *  - **Non-interactive (CI, pipes, `--non-interactive`, `--json`)** —
- *    skip the Ink mount. Print the current values + the wizard tip
- *    so a scripted caller sees the structured envelope without an
- *    unresponsive raw-mode prompt.
- *
- * Idempotency:
- *
- *  - Re-running the wizard reads the CURRENT persisted values (L6
- *    `getGlobalDefaultMode`, L18 `resolveOutputStyle`, this module's
- *    telemetry-state) and surfaces them as the highlighted row, so
- *    pressing Enter on each step is a no-op.
- *
- *  - The marker file (`~/.pugi/.onboarded`) is touched on every
- *    successful completion. The marker existence is what suppresses
- *    the first-run hint on bare `pugi`; resetting it via
- *    `pugi onboarding --reset` re-arms the hint without nuking
- *    persisted values.
- *
- * Exit codes:
- *  0 — wizard completed (interactive OR non-interactive path)
- *  0 — `--reset` cleared the marker
- *  2 — conflicting flags (e.g. `--reset` + a verdict flag)
- *
- * Exit code 0 for non-interactive is intentional: a CI caller running
- * `pugi onboarding --non-interactive` to dump the current state should
- * not see a non-zero rc; failures (fs EIO, unknown flag) raise to the
- * caller via thrown errors which `runtime/cli.ts` catches.
- */
-import { DEFAULT_PERMISSION_MODE, PERMISSION_MODES, PERMISSION_MODE_GLOSS, getGlobalDefaultMode, setGlobalDefaultMode, } from '../../core/permissions/index.js';
-import { OUTPUT_STYLES, OUTPUT_STYLE_SLUGS, } from '../../core/output-style/presets.js';
-import { resolveOutputStyle, setUserOutputStyle, } from '../../core/output-style/state.js';
-import { clearOnboarded, isOnboarded, markOnboarded, } from '../../core/onboarding/marker.js';
-import { TELEMETRY_CHOICES, readTelemetryChoice, writeTelemetryChoice, } from '../../core/onboarding/telemetry-state.js';
-/**
- * Entry point. Parses argv, resolves the snapshot, optionally drives
- * the wizard, writes verdicts to the L6 / L18 / telemetry tiers,
- * touches the marker, and emits a single structured payload via
- * `writeOutput`.
- */
-export async function runOnboardingCommand(args, ctx) {
-    const flags = parseFlags(args);
-    if (flags === null) {
-        const snapshot = readSnapshot(ctx);
-        ctx.writeOutput(buildPayload({
-            status: 'invalid_flags',
-            before: snapshot,
-            after: snapshot,
-            hints: [],
-            message: invalidFlagsMessage(args),
-        }), invalidFlagsMessage(args));
-        return 2;
-    }
-    if (flags.reset) {
-        const before = readSnapshot(ctx);
-        clearOnboarded(ctx.env ?? process.env);
-        const after = readSnapshot(ctx);
-        const message = 'Onboarding marker cleared. Run `pugi onboarding` to walk the wizard again.';
-        ctx.writeOutput(buildPayload({
-            status: 'reset',
-            before,
-            after,
-            hints: [],
-            message,
-        }), `${message}\n`);
-        return 0;
-    }
-    const before = readSnapshot(ctx);
-    if (!ctx.interactive || flags.nonInteractive) {
-        const text = renderSnapshotCard(before, {
-            heading: 'Pugi onboarding — current configuration',
-            footer: 'Re-run `pugi onboarding` from a real terminal to walk the wizard interactively.',
-        });
-        ctx.writeOutput(buildPayload({
-            status: 'non_interactive',
-            before,
-            after: before,
-            hints: buildHints(before),
-            message: text,
-        }), `${text}\n`);
-        return 0;
-    }
-    const verdict = await invokeWizard(ctx, before);
-    if (verdict.cancelled) {
-        const text = 'Onboarding cancelled. No changes written.';
-        ctx.writeOutput(buildPayload({
-            status: 'cancelled',
-            before,
-            after: before,
-            hints: buildHints(before),
-            message: text,
-        }), `${text}\n`);
-        return 0;
-    }
-    applyVerdict(verdict, ctx);
-    markOnboarded(ctx.env ?? process.env);
-    const after = readSnapshot(ctx);
-    const text = renderSnapshotCard(after, {
-        heading: 'Setup complete.',
-        footer: 'Run `pugi doctor` to verify your environment.',
-    });
-    ctx.writeOutput(buildPayload({
-        status: 'completed',
-        before,
-        after,
-        hints: buildHints(after),
-        message: text,
-    }), `${text}\n`);
-    return 0;
-}
-/**
- * Pure snapshot reader. Called twice per invocation (before + after)
- * so the payload can surface the diff a scripted caller would see.
- */
-export function readSnapshot(ctx) {
-    const permissionMode = getGlobalDefaultMode(ctx.homeDir) ?? DEFAULT_PERMISSION_MODE;
-    const styleResolution = resolveOutputStyle({
-        workspaceRoot: ctx.workspaceRoot,
-        env: ctx.env ?? process.env,
-    });
-    const telemetry = readTelemetryChoice({ env: ctx.env ?? process.env });
-    const previouslyOnboarded = isOnboarded(ctx.env ?? process.env);
-    return {
-        authPresent: ctx.authPresent,
-        permissionMode,
-        outputStyle: styleResolution.slug,
-        outputStyleSource: styleResolution.source,
-        telemetry,
-        previouslyOnboarded,
-    };
-}
-/**
- * Apply the wizard's verdict. Each step is independent — operator can
- * skip individual steps (verdict.X === null) and only the non-null
- * values write through to disk.
- */
-function applyVerdict(verdict, ctx) {
-    if (verdict.permissionMode !== null) {
-        setGlobalDefaultMode(verdict.permissionMode, ctx.homeDir);
-    }
-    if (verdict.outputStyle !== null) {
-        setUserOutputStyle(verdict.outputStyle, {
-            workspaceRoot: ctx.workspaceRoot,
-            env: ctx.env ?? process.env,
-        });
-    }
-    if (verdict.telemetry !== null) {
-        writeTelemetryChoice(verdict.telemetry, { env: ctx.env ?? process.env });
-    }
-}
-/**
- * Render the recap card surfaced both as the Step 6 exit screen and
- * as the non-interactive snapshot dump.
- */
-export function renderSnapshotCard(snapshot, opts) {
-    const styleGloss = OUTPUT_STYLES[snapshot.outputStyle].gloss;
-    const modeGloss = PERMISSION_MODE_GLOSS[snapshot.permissionMode];
-    const telemetryGloss = TELEMETRY_GLOSS[snapshot.telemetry];
-    const authLine = snapshot.authPresent
-        ? 'Signed in (run `pugi whoami` for details).'
-        : 'Not signed in. Run `pugi login` to authenticate.';
-    const lines = [
-        opts.heading,
-        '',
-        ` Auth:           ${authLine}`,
-        ` Permission mode: ${snapshot.permissionMode} — ${modeGloss}`,
-        ` Output style:   ${snapshot.outputStyle} (${snapshot.outputStyleSource}) — ${styleGloss}`,
-        ` Telemetry:      ${snapshot.telemetry} — ${telemetryGloss}`,
-        ` MCP servers:    add via \`pugi mcp add <name> <command>\``,
-        '',
-        opts.footer,
-    ];
-    return lines.join('\n');
-}
-/**
- * Build the hint list — auth pointer + re-onboarding tip. Hints are
- * structured (in the payload) so a JSON caller can dispatch on them.
- */
-function buildHints(snapshot) {
-    const hints = [];
-    if (!snapshot.authPresent) {
-        hints.push('Run `pugi login` to sign in. Pugi works offline-first but auth unlocks the engine + sync.');
-    }
-    if (snapshot.previouslyOnboarded) {
-        hints.push('You have onboarded before — re-running the wizard is safe; Enter on any step keeps the current value.');
-    }
-    hints.push('Run `pugi doctor` to verify your environment.');
-    hints.push('Add MCP servers with `pugi mcp add` or list them via `pugi mcp list`.');
-    return Object.freeze(hints);
-}
-/**
- * Drive the wizard. Production callers leave `ctx.promptWizard`
- * undefined, in which case we dynamic-import the Ink wizard so the
- * command module stays free of the React/Ink module graph on the
- * non-interactive path. Specs inject a stub.
- */
-async function invokeWizard(ctx, snapshot) {
-    if (ctx.promptWizard) {
-        return ctx.promptWizard(snapshot);
-    }
-    const { renderOnboardingWizard } = await import('../../tui/onboarding-wizard.js');
-    return renderOnboardingWizard({ snapshot });
-}
-/**
- * Flag parser. Returns `null` on conflicting flags so the runner can
- * emit `invalid_flags` + rc=2 without a thrown error.
- */
-function parseFlags(args) {
-    let reset = false;
-    let nonInteractive = false;
-    for (const arg of args) {
-        if (arg === '--reset') {
-            reset = true;
-        }
-        else if (arg === '--non-interactive' || arg === '--no-tty') {
-            nonInteractive = true;
-        }
-        else {
-            return null;
-        }
-    }
-    // `--reset` + `--non-interactive` is redundant but not conflicting — reset wins.
-    // No other combinations are illegal at the moment.
-    return { reset, nonInteractive };
-}
-function invalidFlagsMessage(args) {
-    return [
-        `pugi onboarding: unknown flag in \`${args.join(' ')}\`.`,
-        'Usage: pugi onboarding [--reset] [--non-interactive]',
-    ].join('\n');
-}
-/**
- * One-line gloss per telemetry choice — surfaced in the recap card.
- * Mirrors the brand voice (no hedging, operator-grade).
- */
-const TELEMETRY_GLOSS = Object.freeze({
-    off: 'No telemetry of any kind.',
-    anonymous: 'Counts + error categories only; no payloads.',
-    community: 'Anonymous + opt-in usage panels.',
-});
-function buildPayload(input) {
-    return {
-        command: 'onboarding',
-        status: input.status,
-        snapshotBefore: input.before,
-        snapshotAfter: input.after,
-        permissionModes: PERMISSION_MODES,
-        outputStyles: OUTPUT_STYLE_SLUGS,
-        telemetryChoices: TELEMETRY_CHOICES,
-        hints: input.hints,
-        message: input.message,
-    };
-}
-//# sourceMappingURL=onboarding.js.map

package/dist/runtime/commands/patch.js

@@ -1,128 +0,0 @@
-/**
- * `pugi patch` — Phase 1.
- *
- * Apply a unified-diff patch from stdin or a file. The dominant use is
- * the `pugi patch < patch.diff` shell pattern that lets external tools
- * (Codex, manual `git diff`) hand off changes through pugi's same
- * security gate the layers use.
- *
- * Surface:
- *
- *  pugi patch                 # read patch from stdin
- *  pugi patch <file.diff>     # read patch from file
- *  pugi patch --dry-run       # run --check only, report
- *  pugi patch --3way --base=<sha> # enable git apply --3way fuzz
- *
- * Exit codes:
- *
- *  0 patch applied (or dry-run check passed)
- *  1 patch rejected (any non-security reason)
- *  2 usage error
- *  3 security gate refused the patch (path traversal / protected file / symlink escape)
- *
- * Distinct exit codes let CI loops differentiate "operator typo" from
- * "model produced a hostile patch" — the latter is a security event
- * worth alerting on.
- *
- * Brand voice: ASCII only, no emoji, no banned words.
- */
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { applyPatch } from '../../tools/apply-patch.js';
-import { FileReadCache } from '../../core/file-cache.js';
-import { openSession } from '../../core/session.js';
-import { loadSettings } from '../../core/settings.js';
-const SECURITY_REASONS = new Set(['path_outside_workspace', 'protected_file', 'symlink_escape']);
-export async function runPatchCommand(args, opts) {
-    const positional = [];
-    const applyOpts = {};
-    // Seed from caller-supplied options first; arg-flag parsing below
-    // overrides when present.
-    if (opts.dryRun)
-        applyOpts.dryRun = true;
-    if (opts.baseSha)
-        applyOpts.baseSha = opts.baseSha;
-    let threeWaySeen = false;
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i] ?? '';
-        if (arg === '--dry-run')
-            applyOpts.dryRun = true;
-        else if (arg === '--3way') {
-            // honored only when --base is also supplied
-            threeWaySeen = true;
-        }
-        else if (arg === '--base') {
-            const next = args[i + 1];
-            if (next)
-                applyOpts.baseSha = next;
-            i += 1;
-        }
-        else if (arg.startsWith('--base=')) {
-            applyOpts.baseSha = arg.slice('--base='.length);
-        }
-        else if (arg === '--json') {
-            // already parsed by the outer CLI
-        }
-        else {
-            positional.push(arg);
-        }
-    }
-    // R1 fix (2026-05-26, PR r1, P2 #14): `--3way` without `--base`
-    // is meaningless because `git apply --3way` falls back to the index,
-    // which a CLI-side `pugi patch` invocation does not have populated
-    // with the patch's pre-image. Warn the operator instead of dropping
-    // the flag silently.
-    if (threeWaySeen && !applyOpts.baseSha) {
-        const warn = opts.warn ?? ((m) => console.warn(m));
-        warn('warning: --3way ignored without --base=<sha>; pass --base or drop --3way');
-    }
-    let patch;
-    try {
-        patch = await readPatchSource(positional[0], opts);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return failure({ ok: false, filesChanged: [], reason: 'invalid_patch', detail: message }, opts.json, 2);
-    }
-    const ctx = {
-        root: opts.cwd,
-        settings: loadSettings(opts.cwd),
-        session: openSession(opts.cwd),
-        readCache: new FileReadCache(),
-    };
-    const result = applyPatch(ctx, patch, applyOpts);
-    if (!result.ok) {
-        const exitCode = result.reason && SECURITY_REASONS.has(result.reason) ? 3 : 1;
-        return failure(result, opts.json, exitCode);
-    }
-    const text = opts.json
-        ? JSON.stringify(result, null, 2)
-        : `applied ${result.filesChanged.length} files:\n ${result.filesChanged.join('\n ')}`;
-    return { ok: true, text, exitCode: 0, result };
-}
-function failure(result, json, exitCode) {
-    const text = json
-        ? JSON.stringify(result, null, 2)
-        : `patch refused: ${result.reason ?? 'unknown'}${result.detail ? `\n ${result.detail}` : ''}`;
-    return { ok: false, text, exitCode, result };
-}
-async function readPatchSource(filePath, opts) {
-    if (filePath) {
-        const resolved = resolve(opts.cwd, filePath);
-        return readFileSync(resolved, 'utf8');
-    }
-    if (opts.stdinOverride !== undefined)
-        return opts.stdinOverride;
-    // Read all of stdin. The process pipe is the canonical CLI handoff
-    // for inbound diffs (e.g. `git diff origin/main | pugi patch`).
-    return new Promise((resolveFn, rejectFn) => {
-        let body = '';
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => {
-            body += chunk;
-        });
-        process.stdin.on('end', () => resolveFn(body));
-        process.stdin.on('error', (error) => rejectFn(error));
-    });
-}
-//# sourceMappingURL=patch.js.map