@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.87

package/dist/runtime/commands/model.js

@@ -0,0 +1,237 @@
+/**
+ * `/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

@@ -0,0 +1,275 @@
+/**
+ * — `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

@@ -0,0 +1,128 @@
+/**
+ * `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