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

package/dist/runtime/commands/undo.js

@@ -1,361 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { hashContent } from '../../core/file-cache.js';
-import { recordFileMutation, recordToolCall, recordToolResult, } from '../../core/session.js';
-import { writeBlob } from './redo-blob-store.js';
-/**
- * `pugi undo` — revert the file mutations from the most recent successful
- * `write` / `edit` / `multi_edit` tool result.
- *
- * Walk strategy:
- *  1. Read `.pugi/events.jsonl` line by line into an array.
- *  2. Walk backwards. Find the most recent `tool_result` whose
- *     `status === 'success'` and whose linked `tool_call` names a
- *     mutating tool (write / edit / multi_edit).
- *  3. From that point, gather every `file_mutation` event that shares
- *     the same `toolCallId`. M1 records one `file_mutation` per
- *     mutating tool call, but the loop is shaped for the multi_edit
- *     future case where a single tool call mutates many files.
- *
- * Restore strategy (M1 — no blob store yet):
- *  For each mutation we restore from the workspace's git history when
- *  possible, with a strict safety gate to avoid silently overwriting
- *  the user's WORK-IN-PROGRESS:
- *
- *  - `operation: create` → unlink the created file iff its current
- *    sha256 matches the recorded `afterHash`. Skip otherwise (the user
- *    has edited it since; refuse to delete their work).
- *  - `operation: update` → restore from `HEAD:<path>` iff (a) the file
- *    was tracked at HEAD AND (b) the HEAD content's sha256 matches the
- *    recorded `beforeHash`. Otherwise abort the turn (no partial
- *    reverts — the spec is atomic).
- *  - `operation: delete` → restore the deleted file from `HEAD:<path>`
- *    if tracked there; skip otherwise.
- *
- * If any single restore is unsafe the whole turn aborts with exit code
- * 1 and no files are touched.
- *
- * Why git as the backing store: the file cache stores hash + metadata
- * but NOT raw content (see `core/file-cache.ts`). M1 ships without a
- * dedicated blob CAS; `git show HEAD:<path>` is the cheapest authoritative
- * source for pre-mutation content as long as the workspace is a git
- * repository. The SQLite session store will replace this with a
- * proper before-blob ledger.
- */
-const MUTATING_TOOLS = new Set(['write', 'edit', 'multi_edit']);
-export async function runUndoCommand(_args, ctx) {
-    const eventsPath = resolve(ctx.workspaceRoot, '.pugi/events.jsonl');
-    if (!existsSync(eventsPath)) {
-        ctx.writeOutput({ command: 'undo', status: 'noop', reason: 'no_session' }, 'No session events found. Nothing to undo.');
-        return;
-    }
-    const events = parseEvents(eventsPath);
-    const target = findLastMutationTurn(events);
-    if (!target) {
-        ctx.writeOutput({ command: 'undo', status: 'noop', reason: 'no_mutation' }, 'No mutating tool result found in the session log.');
-        return;
-    }
-    if (target.mutations.length === 0) {
-        ctx.writeOutput({
-            command: 'undo',
-            status: 'noop',
-            reason: 'no_file_mutations',
-            toolCallId: target.toolCallId,
-        }, `Tool call ${target.toolCallId} recorded no file mutations.`);
-        return;
-    }
-    // Pre-flight: confirm every mutation is reversible before touching
-    // disk. This keeps the operation atomic per spec.
-    const plan = planReverts(ctx.workspaceRoot, target.mutations);
-    if (plan.aborted) {
-        ctx.writeOutput({
-            command: 'undo',
-            status: 'aborted',
-            reason: plan.reason,
-            toolCallId: target.toolCallId,
-            unsafe: plan.unsafe,
-        }, `Refusing to undo ${target.toolCallId}: ${plan.reason}`);
-        process.exitCode = 1;
-        return;
-    }
-    const restored = [];
-    for (const step of plan.steps) {
-        try {
-            // : snapshot the AFTER state into the redo
-            // blob store BEFORE we revert the file on disk. /redo reads this
-            // blob keyed by `step.beforeHash` (= original afterHash) to
-            // reapply the change. We only snapshot for operations that have
-            // on-disk AFTER content: `create` (file exists, about to be
-            // deleted) and `update` (file exists, about to be overwritten).
-            // For `delete` reverts (file was deleted by Pugi, the "after" is
-            // nothing) redo replays the delete itself — no content needed.
-            // Best-effort: a blob-store failure must not abort the undo, so
-            // the writeBlob call is wrapped и any error swallowed.
-            if (step.operation === 'create' || step.operation === 'update') {
-                try {
-                    const abs = resolve(ctx.workspaceRoot, step.path);
-                    if (existsSync(abs) && step.beforeHash) {
-                        const current = readFileSync(abs, 'utf8');
-                        // Defensive: only snapshot if the current sha matches the
-                        // pre-revert hash the planner verified. The planner already
-                        // gated this, but a TOCTOU between plan + execute would
-                        // produce a wrong blob — silently dropping it is safer than
-                        // shipping content under the wrong sha.
-                        if (hashContent(current) === step.beforeHash) {
-                            writeBlob(ctx.workspaceRoot, current);
-                        }
-                    }
-                }
-                catch {
-                    // Best-effort. Failure to snapshot means /redo will report
-                    // "no captured content" — operator can re-run the mutation
-                    // manually. Better than aborting the undo.
-                }
-            }
-            executeRevert(ctx.workspaceRoot, step);
-            restored.push({ path: step.path, operation: step.operation });
-        }
-        catch (error) {
-            // A revert failed after pre-flight said it was safe. Surface the
-            // error and bail out — the spec says no partial state on failure.
-            const message = error instanceof Error ? error.message : String(error);
-            ctx.writeOutput({
-                command: 'undo',
-                status: 'failed',
-                reason: message,
-                toolCallId: target.toolCallId,
-                restored,
-                failedAt: step.path,
-            }, `Undo failed mid-flight on ${step.path}: ${message}`);
-            process.exitCode = 1;
-            return;
-        }
-    }
-    // Audit the inverse mutations so the event log explains the undo.
-    const toolCallId = recordToolCall(ctx.session, 'undo', `revert ${target.toolCallId}`);
-    for (const step of plan.steps) {
-        recordFileMutation(ctx.session, {
-            toolCallId,
-            path: step.path,
-            operation: step.operation === 'create' ? 'delete' : 'update',
-            beforeHash: step.beforeHash,
-            afterHash: step.afterHash,
-        });
-    }
-    recordToolResult(ctx.session, toolCallId, 'success', `Undid ${restored.length} mutation(s) from ${target.toolCallId}`);
-    ctx.writeOutput({
-        command: 'undo',
-        status: 'ok',
-        toolCallId: target.toolCallId,
-        restored,
-    }, [
-        `Undid ${restored.length} mutation(s) from ${target.toolCallId}:`,
-        ...restored.map((entry) => ` ${entry.operation.padEnd(7)} ${entry.path}`),
-    ].join('\n'));
-}
-function parseEvents(eventsPath) {
-    const raw = readFileSync(eventsPath, 'utf8');
-    const lines = raw.split('\n').filter((line) => line.trim().length > 0);
-    const out = [];
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                out.push(parsed);
-            }
-        }
-        catch {
-            // Drop malformed lines silently — partial writes mid-shutdown can
-            // produce them and undo should still work for the rest.
-        }
-    }
-    return out;
-}
-function findLastMutationTurn(events) {
-    const toolCalls = new Map();
-    const results = [];
-    for (let i = 0; i < events.length; i += 1) {
-        const event = events[i];
-        if (!event)
-            continue;
-        if (event.type === 'tool_call' && typeof event.id === 'string' && typeof event.tool === 'string') {
-            toolCalls.set(event.id, { id: event.id, tool: event.tool });
-        }
-        else if (event.type === 'tool_result' &&
-            typeof event.id === 'string' &&
-            typeof event.toolCallId === 'string' &&
-            (event.status === 'success' || event.status === 'error' || event.status === 'cancelled')) {
-            results.push({
-                id: event.id,
-                toolCallId: event.toolCallId,
-                status: event.status,
-                index: i,
-            });
-        }
-    }
-    for (let i = results.length - 1; i >= 0; i -= 1) {
-        const result = results[i];
-        if (result.status !== 'success')
-            continue;
-        const call = toolCalls.get(result.toolCallId);
-        if (!call)
-            continue;
-        if (!MUTATING_TOOLS.has(call.tool))
-            continue;
-        // Collect file_mutation events whose toolCallId matches. We do NOT
-        // window by event index: M1 emits the file_mutation alongside the
-        // tool_result, but a future iteration that emits them earlier
-        // (e.g. mid-stream for multi_edit) still maps correctly.
-        const mutations = [];
-        for (const event of events) {
-            if (event.type !== 'file_mutation')
-                continue;
-            if (event.toolCallId !== result.toolCallId)
-                continue;
-            if (typeof event.path !== 'string')
-                continue;
-            if (event.operation !== 'create' &&
-                event.operation !== 'update' &&
-                event.operation !== 'delete' &&
-                event.operation !== 'move') {
-                continue;
-            }
-            mutations.push({
-                toolCallId: result.toolCallId,
-                path: event.path,
-                operation: event.operation,
-                beforeHash: typeof event.beforeHash === 'string' ? event.beforeHash : undefined,
-                afterHash: typeof event.afterHash === 'string' ? event.afterHash : undefined,
-            });
-        }
-        return {
-            toolCallId: result.toolCallId,
-            resultIndex: result.index,
-            tool: call.tool,
-            mutations,
-        };
-    }
-    return null;
-}
-function planReverts(root, mutations) {
-    const steps = [];
-    const unsafe = [];
-    for (const mutation of mutations) {
-        const abs = resolve(root, mutation.path);
-        switch (mutation.operation) {
-            case 'create': {
-                if (!existsSync(abs)) {
-                    // Already gone — nothing to undo for this entry.
-                    continue;
-                }
-                const current = readFileSync(abs, 'utf8');
-                const currentHash = hashContent(current);
-                if (!mutation.afterHash || currentHash !== mutation.afterHash) {
-                    unsafe.push(`${mutation.path}: created by Pugi, then modified by the user — refusing to delete uncommitted work`);
-                    continue;
-                }
-                steps.push({
-                    path: mutation.path,
-                    operation: 'create',
-                    beforeHash: mutation.afterHash,
-                    afterHash: undefined,
-                });
-                break;
-            }
-            case 'update': {
-                if (!existsSync(abs)) {
-                    unsafe.push(`${mutation.path}: file expected to exist for update revert, not found`);
-                    continue;
-                }
-                const current = readFileSync(abs, 'utf8');
-                const currentHash = hashContent(current);
-                if (!mutation.afterHash || currentHash !== mutation.afterHash) {
-                    unsafe.push(`${mutation.path}: updated by Pugi, then modified by the user — refusing to overwrite uncommitted work`);
-                    continue;
-                }
-                const headContent = readHead(root, mutation.path);
-                if (headContent === null) {
-                    unsafe.push(`${mutation.path}: no git HEAD version available for revert`);
-                    continue;
-                }
-                if (mutation.beforeHash && hashContent(headContent) !== mutation.beforeHash) {
-                    unsafe.push(`${mutation.path}: git HEAD differs from the pre-mutation hash — refusing to restore an unverifiable version`);
-                    continue;
-                }
-                steps.push({
-                    path: mutation.path,
-                    operation: 'update',
-                    beforeHash: mutation.afterHash,
-                    afterHash: mutation.beforeHash,
-                    restoreContent: headContent,
-                });
-                break;
-            }
-            case 'delete': {
-                const headContent = readHead(root, mutation.path);
-                if (headContent === null) {
-                    unsafe.push(`${mutation.path}: deleted file has no git HEAD version, cannot restore`);
-                    continue;
-                }
-                if (mutation.beforeHash && hashContent(headContent) !== mutation.beforeHash) {
-                    unsafe.push(`${mutation.path}: git HEAD differs from the pre-deletion hash, cannot restore safely`);
-                    continue;
-                }
-                steps.push({
-                    path: mutation.path,
-                    operation: 'delete',
-                    beforeHash: undefined,
-                    afterHash: mutation.beforeHash,
-                    restoreContent: headContent,
-                });
-                break;
-            }
-            case 'move':
-                // Move reverts are not in M1 scope — the tool layer does not yet
-                // emit `move` mutations. Flag as unsafe so a future operator who
-                // hits this gets a clear failure instead of partial revert.
-                unsafe.push(`${mutation.path}: move undo is not supported in M1`);
-                break;
-        }
-    }
-    if (unsafe.length > 0) {
-        return {
-            aborted: true,
-            reason: 'one or more files are unsafe to revert',
-            unsafe,
-            steps: [],
-        };
-    }
-    return { aborted: false, steps };
-}
-function executeRevert(root, step) {
-    const abs = resolve(root, step.path);
-    if (step.operation === 'create') {
-        // We previously created the file. Reverting means deleting it.
-        unlinkSync(abs);
-        return;
-    }
-    if (step.restoreContent === undefined) {
-        throw new Error(`internal: restoreContent missing for ${step.path}`);
-    }
-    // Atomic write via tmp+rename — same pattern as file-tools.writeTool.
-    const tmp = `${abs}.pugi-undo-${Date.now()}`;
-    writeFileSync(tmp, step.restoreContent, { encoding: 'utf8', mode: 0o600 });
-    renameSync(tmp, abs);
-}
-function readHead(root, path) {
-    try {
-        const out = execFileSync('git', ['show', `HEAD:${path}`], {
-            cwd: root,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-            maxBuffer: 64 * 1024 * 1024,
-        });
-        return out;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=undo.js.map

package/dist/runtime/commands/update.js

@@ -1,289 +0,0 @@
-/**
- * — `pugi update` dispatcher.
- *
- * Top-level command + in-REPL `/update` slash share this handler.
- * Both surfaces delegate IO + persistence here so the channel
- * resolution, the registry probe, and the install shell-out stay
- * single-sourced.
- *
- * Command grammar:
- *
- *  pugi update                    -> probe + interactive prompt
- *  pugi update --check            -> probe + JSON envelope (scripted)
- *  pugi update --channel <name>   -> switch channel + probe
- *  pugi update --apply            -> probe + shell `npm i -g …`
- *                                     (confirms unless --yes)
- *  pugi update --apply --yes      -> probe + shell, no confirmation
- *
- * Exit codes:
- *
- *  0 — happy path (no update OR update completed) OR `--check` JSON
- *  1 — install / probe failure with structured error envelope
- *  2 — argument error (bad channel, conflicting flags)
- *
- * R2 atomic swap deferred (sprint plan L27 mention): the upstream behavior
- * also describes the upstream tool's R2-backed binary swap. Pugi ships
- * exclusively via npm today; building a parallel R2 distribution
- * channel + checksum verification + rollback is materially more work
- * than the L27 acceptance criteria allow. Document the deferral in
- * the PR body and revisit when npm's once-per-day rate-limit or
- * outage cadence justifies the parallel pipeline.
- */
-import { spawn } from 'node:child_process';
-import { homedir } from 'node:os';
-import { DEFAULT_UPDATE_CHANNEL, UPDATE_CHANNELS, describeChannel, npmTagForChannel, parseUpdateChannel, } from '../../core/auto-update/channels.js';
-import { checkForChannelUpdate, } from '../../core/auto-update/checker.js';
-import { resolveEffectiveChannel, setUpdateChannel, writeLastCheckedAt, } from '../../core/auto-update/state.js';
-import { PUGI_CLI_VERSION } from '../version.js';
-/**
- * Default subprocess runner. Spawns `npm install -g @pugi/cli@<tag>`
- * inheriting stdio so the operator sees the live npm output.
- */
-export function defaultSpawnInstaller(channel) {
-    const tag = npmTagForChannel(channel);
-    const args = ['install', '-g', `@pugi/cli@${tag}`];
-    return new Promise((resolvePromise) => {
-        const child = spawn('npm', args, { stdio: 'inherit' });
-        child.on('exit', (code) => {
-            resolvePromise(typeof code === 'number' ? code : 1);
-        });
-        child.on('error', () => {
-            // ENOENT / EACCES — npm not on PATH or permission denied. We
-            // surface a non-zero code so the dispatcher's JSON envelope
-            // tells the operator the apply failed; the inherited stdio
-            // already printed the underlying error to the terminal.
-            resolvePromise(127);
-        });
-    });
-}
-/**
- * Parse a CLI / slash argv into our `UpdateCommandFlags`. Returns
- * `null` AND writes the usage error via `writeError` for conflicting
- * combinations. Both `pugi update` and the in-REPL `/update <args>`
- * surface call through this so the validation lives in one place.
- */
-export function parseUpdateArgs(argv, options = {}) {
-    let check = false;
-    let apply = false;
-    let yes = false;
-    let json = options.jsonDefault ?? false;
-    let channel = null;
-    let channelInvalid;
-    for (let i = 0; i < argv.length; i += 1) {
-        const token = argv[i] ?? '';
-        if (token === '--check') {
-            check = true;
-        }
-        else if (token === '--apply') {
-            apply = true;
-        }
-        else if (token === '--yes' || token === '-y') {
-            yes = true;
-        }
-        else if (token === '--json') {
-            json = true;
-        }
-        else if (token === '--channel') {
-            const value = argv[i + 1];
-            i += 1;
-            const parsed = parseUpdateChannel(value);
-            if (!parsed) {
-                channelInvalid = value ?? '';
-                continue;
-            }
-            channel = parsed;
-        }
-        else if (token.startsWith('--channel=')) {
-            const value = token.slice('--channel='.length);
-            const parsed = parseUpdateChannel(value);
-            if (!parsed) {
-                channelInvalid = value;
-                continue;
-            }
-            channel = parsed;
-        }
-        else {
-            return {
-                error: `pugi update: unknown argument '${token}'. See \`pugi update --help\`.`,
-            };
-        }
-    }
-    if (channelInvalid !== undefined) {
-        return {
-            error: `pugi update: unknown channel '${channelInvalid}'. Allowed: ${UPDATE_CHANNELS.join(' / ')}.`,
-        };
-    }
-    return {
-        check,
-        apply,
-        yes,
-        json,
-        channel,
-    };
-}
-/**
- * Run the full command. Returns the structured envelope so the in-
- * REPL slash can decide whether to render the human-readable text OR
- * pretty-print the JSON.
- */
-export async function runUpdateCommand(ctx) {
-    const flags = ctx.flags;
-    const home = ctx.home;
-    // 1. Resolve channel. `--channel <name>` wins; otherwise read the
-    //   persisted preference; otherwise hard default `beta`.
-    const cliFlagChannel = flags.channel;
-    const effectiveChannel = resolveEffectiveChannel({
-        cliFlag: cliFlagChannel,
-        homeDir: home,
-    });
-    // 2. Persist the channel switch BEFORE the probe so a probe failure
-    //   still leaves the operator on the channel they asked for.
-    let switched = false;
-    if (cliFlagChannel) {
-        setUpdateChannel(cliFlagChannel, home);
-        switched = true;
-    }
-    // 3. Probe the registry.
-    const outcome = await checkForChannelUpdate({
-        channel: effectiveChannel,
-        currentVersion: PUGI_CLI_VERSION,
-        ...(ctx.fetchImpl ? { fetchImpl: ctx.fetchImpl } : {}),
-        ...(ctx.registryUrl ? { registryUrl: ctx.registryUrl } : {}),
-    });
-    // 4. Record the timestamp on a successful probe (regardless of
-    //   whether an update is available). Failed probes do NOT update
-    //   the timestamp so the cold-start banner retries on the next
-    //   invocation.
-    if (!outcome.error) {
-        const now = ctx.now ? new Date(ctx.now()) : new Date();
-        try {
-            writeLastCheckedAt(now, home);
-        }
-        catch {
-            // Best-effort — a read-only home should not crash the dispatcher.
-        }
-    }
-    // 5. Build the envelope shape ALL action paths share.
-    const baseEnvelope = {
-        command: 'update',
-        ok: outcome.error === null,
-        available: outcome.available,
-        channel: outcome.channel,
-        npmTag: outcome.npmTag,
-        current: outcome.current,
-        latest: outcome.latest,
-        gap: outcome.gap,
-        installCommand: outcome.installCommand,
-        action: outcome.error ? 'error' : 'probe',
-        error: outcome.error,
-        meta: { cliVersion: PUGI_CLI_VERSION },
-    };
-    // 6. --check: emit the envelope, never prompt, never apply.
-    if (flags.check) {
-        const text = renderHumanText(baseEnvelope, { switched });
-        ctx.writeOutput(baseEnvelope, text);
-        return baseEnvelope;
-    }
-    // 7. No update available — bail with a friendly message.
-    if (!outcome.available || !outcome.latest) {
-        const envelope = {
-            ...baseEnvelope,
-            action: outcome.error ? 'error' : (switched ? 'switch' : 'no_update'),
-        };
-        const text = renderHumanText(envelope, { switched });
-        ctx.writeOutput(envelope, text);
-        return envelope;
-    }
-    // 8. Update IS available. Branch on --apply.
-    if (!flags.apply) {
-        // Default: print the offer, suggest the install command, leave
-        // the install to the operator. Mirrors the upstream behavior note:
-        // operators install side-effects must remain explicit on the CLI
-        // happy path — `pugi update` showing the gap is informational,
-        // `pugi update --apply` is the destructive verb.
-        const envelope = {
-            ...baseEnvelope,
-            action: switched ? 'switch' : 'probe',
-        };
-        const text = renderHumanText(envelope, { switched });
-        ctx.writeOutput(envelope, text);
-        return envelope;
-    }
-    // 9. --apply path. Confirm unless --yes, then spawn npm.
-    const installer = ctx.spawnInstaller ?? defaultSpawnInstaller;
-    let confirmed = flags.yes;
-    if (!confirmed) {
-        confirmed = await ctx.promptConfirm(`Run \`${outcome.installCommand}\` to update ${outcome.current} -> ${outcome.latest}? [y/N]`);
-    }
-    if (!confirmed) {
-        const envelope = {
-            ...baseEnvelope,
-            action: 'probe',
-            ok: false,
-            error: 'apply_cancelled_by_operator',
-        };
-        const text = `Cancelled. Run \`${outcome.installCommand}\` manually when you are ready.`;
-        ctx.writeOutput(envelope, text);
-        return envelope;
-    }
-    const exitCode = await installer(outcome.channel);
-    const applyEnvelope = {
-        ...baseEnvelope,
-        action: 'apply',
-        installExitCode: exitCode,
-        ok: exitCode === 0,
-        error: exitCode === 0 ? null : `npm_install_exit_${exitCode}`,
-    };
-    const applyText = exitCode === 0
-        ? `Updated to @pugi/cli@${outcome.latest}. Restart your shell so the new binary takes effect.`
-        : `Update failed (npm exit ${exitCode}). Try \`${outcome.installCommand}\` manually.`;
-    ctx.writeOutput(applyEnvelope, applyText);
-    return applyEnvelope;
-}
-/**
- * Build the operator-readable hint that lives next to the JSON
- * envelope. The text + the JSON are both passed to `writeOutput`; the
- * caller (`writeOutput` in cli.ts) picks based on `--json`. Exported
- * so the spec can assert the literal strings the operator sees.
- */
-export function renderHumanText(envelope, options = {}) {
-    const { current, latest, channel, installCommand, available, error } = envelope;
-    const lines = [];
-    lines.push(`Channel: ${channel} — ${describeChannel(channel)}`);
-    if (options.switched) {
-        lines.push(`Persisted channel selection -> ${channel}.`);
-    }
-    if (error) {
-        lines.push(`Update check failed: ${error}`);
-        lines.push(`Manual: \`${installCommand}\` (no probe necessary).`);
-        return lines.join('\n');
-    }
-    if (available && latest) {
-        lines.push(`Update available: ${current} -> ${latest}.`);
-        lines.push(`Run \`${installCommand}\` to upgrade.`);
-        lines.push(`Or \`pugi update --apply\` to upgrade with confirmation.`);
-        return lines.join('\n');
-    }
-    lines.push(`Up to date (${current} is the latest on ${channel}).`);
-    return lines.join('\n');
-}
-/**
- * Render a one-line cold-start hint that callers (REPL boot, doctor
- * banner) splice above their own UI. Returns `null` when there is
- * nothing to nudge the operator about. Pure — no IO.
- */
-export function renderUpdateHint(outcome) {
-    if (!outcome.available || !outcome.latest)
-        return null;
-    return `Update available: ${outcome.current} -> ${outcome.latest}. Run \`pugi update\`.`;
-}
-/**
- * Convenience entry point — resolve the effective channel from
- * `~/.pugi/config.json` + DEFAULT_UPDATE_CHANNEL without forcing the
- * caller to import multiple modules. Used by the cold-start banner +
- * the doctor probe.
- */
-export function effectiveChannel(home = homedir()) {
-    return resolveEffectiveChannel({ homeDir: home }) ?? DEFAULT_UPDATE_CHANNEL;
-}
-//# sourceMappingURL=update.js.map