@pugi/cli 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/runtime/commands/delegate.js

@@ -0,0 +1,289 @@
+/**
+ * Run the delegate command. Parses args, validates the brief, opens a
+ * fresh session, and POSTs the delegate brief.
+ *
+ * Sets `process.exitCode` instead of throwing so the caller (cli.ts
+ * handlers table) does not need a try/catch wrapper.
+ */
+export async function runDelegateCommand(args, ctx) {
+    // Extract the optional `--wait` flag from positional args. Accept it
+    // in any position so `pugi delegate --wait dev "..."` and
+    // `pugi delegate dev "..." --wait` both work; positional ordering of
+    // slug + brief is preserved by filtering the flag out before the
+    // slug/brief split (Claude P2 fix 2026-05-25).
+    const wait = args.some((a) => a === '--wait');
+    const positional = args.filter((a) => a !== '--wait');
+    const slug = positional[0];
+    const brief = positional.slice(1).join(' ').trim();
+    if (!slug || !brief) {
+        ctx.writeOutput({
+            ok: false,
+            error: 'Usage: pugi delegate [--wait] <persona-slug> "<one-sentence brief>"',
+        }, 'Usage: pugi delegate [--wait] <persona-slug> "<one-sentence brief>"');
+        process.exitCode = 2;
+        return;
+    }
+    // Brief size cap mirrors the server-side DTO (8000 chars). The local
+    // gate lets the operator know about the truncation before we waste a
+    // round-trip on a too-large brief.
+    if (brief.length > 8000) {
+        ctx.writeOutput({
+            ok: false,
+            error: `brief is ${brief.length} chars; max 8000`,
+        }, `pugi delegate: brief is ${brief.length} chars; max 8000.`);
+        process.exitCode = 2;
+        return;
+    }
+    const config = ctx.resolveConfig();
+    if (!config) {
+        ctx.writeOutput({
+            ok: false,
+            error: 'no Pugi credential configured; run `pugi login` first',
+        }, 'pugi delegate: no credential configured. Run `pugi login` first.');
+        process.exitCode = 1;
+        return;
+    }
+    const opened = await ctx.openSession(config, ctx.workspaceCwd);
+    if ('error' in opened) {
+        ctx.writeOutput({ ok: false, error: opened.error }, `pugi delegate: session open failed: ${opened.error}`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await ctx.submitDelegate(config, opened.sessionId, {
+        persona: slug,
+        brief,
+    });
+    switch (result.status) {
+        case 'ok': {
+            const ok = result.response;
+            if (!wait) {
+                ctx.writeOutput({
+                    ok: true,
+                    sessionId: opened.sessionId,
+                    dispatchId: ok.dispatchId,
+                    personaSlug: ok.personaSlug,
+                }, `dispatched ${ok.personaSlug} (dispatchId=${ok.dispatchId}); stream via GET /sessions/${opened.sessionId}/stream.`);
+                return;
+            }
+            // --wait: subscribe to SSE until the persona reaches a terminal
+            // event. The waiter contract is provider-shaped so tests can pass
+            // a fake without standing up fetch.
+            const waiter = ctx.waitForTerminal ?? waitForDelegateTerminal;
+            const outcome = await waiter(config, opened.sessionId, ok.personaSlug);
+            switch (outcome.kind) {
+                case 'completed':
+                    ctx.writeOutput({
+                        ok: true,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        personaSlug: outcome.personaSlug,
+                        status: 'completed',
+                    }, `completed ${outcome.personaSlug} (dispatchId=${ok.dispatchId}).`);
+                    return;
+                case 'blocked':
+                    ctx.writeOutput({
+                        ok: false,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        personaSlug: outcome.personaSlug,
+                        status: 'blocked',
+                        detail: outcome.detail,
+                    }, `blocked ${outcome.personaSlug}: ${outcome.detail}`);
+                    process.exitCode = 5;
+                    return;
+                case 'failed':
+                    ctx.writeOutput({
+                        ok: false,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        personaSlug: outcome.personaSlug,
+                        status: 'failed',
+                        error: outcome.error,
+                    }, `failed ${outcome.personaSlug}: ${outcome.error}`);
+                    process.exitCode = 5;
+                    return;
+                case 'stream_error':
+                    ctx.writeOutput({
+                        ok: false,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        error: outcome.error,
+                    }, `pugi delegate --wait: ${outcome.error}`);
+                    process.exitCode = 1;
+                    return;
+            }
+            return;
+        }
+        case 'unknown_persona':
+            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
+            process.exitCode = 3;
+            return;
+        case 'quota_exceeded':
+            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
+            process.exitCode = 4;
+            return;
+        case 'endpoint_missing':
+            ctx.writeOutput({
+                ok: false,
+                error: 'runtime does not expose POST /api/pugi/sessions/:id/delegate (upgrade admin-api to α7.5+)',
+                code: result.code,
+            }, 'pugi delegate: runtime does not expose the delegate endpoint. Upgrade admin-api to α7.5+.');
+            process.exitCode = 1;
+            return;
+        case 'unauthenticated':
+        case 'failed':
+            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
+            process.exitCode = 1;
+            return;
+    }
+}
+/* ------------------------------------------------------------------ */
+/* --wait waiter                                                      */
+/* ------------------------------------------------------------------ */
+/**
+ * Subscribe to the session SSE stream and resolve when the named
+ * persona reaches a terminal event (agent.completed / agent.blocked /
+ * agent.failed). Falls back to a `stream_error` outcome when the
+ * stream closes before any terminal event arrives or when the
+ * underlying fetch fails.
+ *
+ * The waiter is intentionally a single-call helper (not a long-lived
+ * subscriber) - the scripted `pugi delegate --wait` caller wants to
+ * exit on the first terminal event for THIS persona, not maintain a
+ * persistent connection.
+ *
+ * Why we parse the lifecycle in this file (not via the repl-render
+ * subscribe helper): repl-render carries Ink/React deps the
+ * non-interactive delegate path does not want to load. Duplicating the
+ * minimal SSE-line parser here keeps the command lean (this is the same
+ * shape `apps/admin-api/src/pugi/sessions.controller.ts` writes to the
+ * wire).
+ */
+export async function waitForDelegateTerminal(config, sessionId, targetPersonaSlug) {
+    const url = `${config.apiUrl.replace(/\/+$/, '')}/api/pugi/sessions/${encodeURIComponent(sessionId)}/stream`;
+    const controller = new AbortController();
+    // Hard-cap the waiter at 5 minutes so a stalled server cannot keep
+    // a scripted caller hanging forever; the dispatcher's per-turn budget
+    // is well under this.
+    const timeout = setTimeout(() => controller.abort(), 5 * 60 * 1000);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'text/event-stream',
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return { kind: 'stream_error', error: `HTTP ${response.status}` };
+        }
+        if (!response.body) {
+            return { kind: 'stream_error', error: 'no response body' };
+        }
+        // Track the most-recent persona slug seen on agent.spawned so the
+        // terminal event (which carries only taskId) can be matched to the
+        // delegate target without parsing the random nonce suffix.
+        const taskToPersona = new Map();
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        let currentData = '';
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+                return { kind: 'stream_error', error: 'stream ended without terminal event' };
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                const rawLine = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+                buffer = buffer.slice(newlineIndex + 1);
+                if (rawLine.length === 0) {
+                    if (currentData.length > 0) {
+                        const parsed = parseDelegateFrame(currentData);
+                        if (parsed) {
+                            if (parsed.type === 'agent.spawned') {
+                                taskToPersona.set(parsed.taskId, parsed.personaSlug);
+                            }
+                            else if (parsed.type === 'agent.completed' ||
+                                parsed.type === 'agent.blocked' ||
+                                parsed.type === 'agent.failed') {
+                                const slug = taskToPersona.get(parsed.taskId) ?? targetPersonaSlug;
+                                if (slug === targetPersonaSlug) {
+                                    controller.abort();
+                                    if (parsed.type === 'agent.completed') {
+                                        return {
+                                            kind: 'completed',
+                                            personaSlug: slug,
+                                            taskId: parsed.taskId,
+                                        };
+                                    }
+                                    if (parsed.type === 'agent.blocked') {
+                                        return {
+                                            kind: 'blocked',
+                                            personaSlug: slug,
+                                            taskId: parsed.taskId,
+                                            detail: parsed.detail,
+                                        };
+                                    }
+                                    return {
+                                        kind: 'failed',
+                                        personaSlug: slug,
+                                        taskId: parsed.taskId,
+                                        error: parsed.error,
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    currentData = '';
+                    continue;
+                }
+                if (rawLine.startsWith(':'))
+                    continue;
+                const colonIndex = rawLine.indexOf(':');
+                const field = colonIndex === -1 ? rawLine : rawLine.slice(0, colonIndex);
+                const value = colonIndex === -1 ? '' : rawLine.slice(colonIndex + 1).replace(/^ /, '');
+                if (field === 'data') {
+                    currentData = currentData.length === 0 ? value : `${currentData}\n${value}`;
+                }
+            }
+        }
+    }
+    catch (err) {
+        if (controller.signal.aborted) {
+            return { kind: 'stream_error', error: 'wait timed out' };
+        }
+        return { kind: 'stream_error', error: err.message };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function parseDelegateFrame(data) {
+    try {
+        const raw = JSON.parse(data);
+        const type = raw.type;
+        const taskId = typeof raw.taskId === 'string' ? raw.taskId : null;
+        if (!taskId)
+            return null;
+        if (type === 'agent.spawned' && typeof raw.personaSlug === 'string') {
+            return { type, taskId, personaSlug: raw.personaSlug };
+        }
+        if (type === 'agent.completed') {
+            return { type, taskId };
+        }
+        if (type === 'agent.blocked') {
+            return { type, taskId, detail: typeof raw.detail === 'string' ? raw.detail : '' };
+        }
+        if (type === 'agent.failed') {
+            return { type, taskId, error: typeof raw.error === 'string' ? raw.error : '' };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=delegate.js.map

package/dist/runtime/commands/doctor.js

@@ -0,0 +1,369 @@
+/**
+ * `pugi doctor` — environment health report (Leak L17, 2026-05-27).
+ *
+ * Parity command with Claude Code's `/doctor` (gap doc:
+ * docs/research/2026-05-27-pugi-gap-analysis-3-repos.md §6). Probes
+ * auth, API reachability, CLI version, workspace state, disk space,
+ * Node version, pnpm, git, MCP servers, config file, and session
+ * activity. Emits either a human-readable table OR a structured JSON
+ * envelope depending on `--json`.
+ *
+ * Module contract:
+ *
+ *   - This file owns the WIRING from CLI flags + workspace context to
+ *     the probe runner. The probes themselves live in
+ *     `core/diagnostics/probes/*.ts` and have NO module-level coupling
+ *     to the CLI dispatch surface.
+ *
+ *   - `runDoctorCommand` is the single entry point. Both the top-level
+ *     `pugi doctor` handler in `runtime/cli.ts` AND the in-REPL
+ *     `/doctor` slash command call it. The function returns the
+ *     `DoctorReport` so the REPL can render via the Ink table without
+ *     re-running the probes.
+ *
+ *   - Exit codes are derived from `exitCodeFor(overall)` in
+ *     `core/diagnostics/types.ts` and bubble up via `process.exitCode`
+ *     (matches the convention of every other CLI handler in cli.ts).
+ *
+ *   - The MCP probe is opportunistic: if `core/mcp/registry.js` is
+ *     unavailable for any reason (e.g. sibling L13 not yet landed,
+ *     unexpected schema change), the probe degrades to a graceful
+ *     `skipped` result so the rest of the table still renders.
+ */
+import { execFileSync } from 'node:child_process';
+import { constants as fsConstants, existsSync, accessSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolveActiveCredential } from '../../core/credentials.js';
+import { PUGI_CLI_VERSION } from '../version.js';
+import { runProbes, } from '../../core/diagnostics/probe-runner.js';
+import { computeOverall, countProbes, exitCodeFor, } from '../../core/diagnostics/types.js';
+import { probeAuth } from '../../core/diagnostics/probes/auth.js';
+import { probeApi } from '../../core/diagnostics/probes/api.js';
+import { probeCliVersion } from '../../core/diagnostics/probes/cli-version.js';
+import { probeWorkspace } from '../../core/diagnostics/probes/workspace.js';
+import { probeDisk } from '../../core/diagnostics/probes/disk.js';
+import { probeNode } from '../../core/diagnostics/probes/node.js';
+import { probePnpm } from '../../core/diagnostics/probes/pnpm.js';
+import { probeGit } from '../../core/diagnostics/probes/git.js';
+import { probeMcp } from '../../core/diagnostics/probes/mcp.js';
+import { probeConfig } from '../../core/diagnostics/probes/config.js';
+import { probeSession } from '../../core/diagnostics/probes/session.js';
+import { probeDenialTracking } from '../../core/diagnostics/probes/denial-tracking.js';
+/**
+ * Default API URL when no PUGI_API_URL env override is set. Mirrors
+ * the constant in `core/credentials.ts` (kept local to avoid an
+ * extra named export from that module).
+ */
+const DEFAULT_API_URL = 'https://api.pugi.io';
+/**
+ * Build the standard probe set with production dependencies. Exported
+ * for the spec so the test can construct the same suite with stub
+ * deps + assert per-probe ordering + fail-isolation in isolation.
+ */
+export function buildDefaultProbes(ctx, options = {}) {
+    const fetchImpl = ctx.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    const now = Date.now;
+    const probes = [
+        {
+            name: 'AUTH',
+            run: () => probeAuth(ctx, {
+                resolveCredential: (env, home) => {
+                    const credential = resolveActiveCredential(env, home);
+                    if (!credential)
+                        return null;
+                    return { apiUrl: credential.apiUrl, apiKey: credential.apiKey };
+                },
+                fetchImpl,
+                now,
+            }),
+            timeoutMs: 4_000,
+        },
+        {
+            name: 'API',
+            run: () => probeApi(ctx, {
+                resolveApiUrl: (env) => {
+                    return env.PUGI_API_URL ?? DEFAULT_API_URL;
+                },
+                fetchImpl,
+                now,
+            }),
+            timeoutMs: 4_000,
+        },
+        {
+            name: 'CLI VERSION',
+            run: () => probeCliVersion({
+                localVersion: options.localCliVersion ?? PUGI_CLI_VERSION,
+                fetchImpl,
+                now,
+            }),
+            timeoutMs: 4_000,
+        },
+        {
+            name: 'WORKSPACE',
+            run: async () => probeWorkspace(ctx, {
+                existsSync,
+                statSync,
+                accessSync,
+                W_OK: fsConstants.W_OK,
+            }),
+        },
+        {
+            name: 'DISK',
+            run: async () => probeDisk(ctx, {
+                getFreeBytes: (home) => getFreeBytesViaDf(home),
+            }),
+        },
+        {
+            name: 'NODE',
+            run: async () => probeNode({ version: process.version }),
+        },
+        {
+            name: 'PNPM',
+            run: async () => probePnpm({
+                resolveVersion: () => execFileSync('pnpm', ['--version'], {
+                    encoding: 'utf8',
+                    timeout: 2_000,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }).trim(),
+            }),
+        },
+        {
+            name: 'GIT',
+            run: async () => probeGit(ctx, {
+                resolveVersion: () => execFileSync('git', ['--version'], {
+                    encoding: 'utf8',
+                    timeout: 2_000,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }).trim(),
+                isInWorkTree: (cwd) => {
+                    try {
+                        const result = execFileSync('git', ['-C', cwd, 'rev-parse', '--is-inside-work-tree'], {
+                            encoding: 'utf8',
+                            timeout: 2_000,
+                            stdio: ['ignore', 'pipe', 'ignore'],
+                        }).trim();
+                        return result === 'true';
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                resolveHeadSha: (cwd) => {
+                    try {
+                        return execFileSync('git', ['-C', cwd, 'rev-parse', 'HEAD'], {
+                            encoding: 'utf8',
+                            timeout: 2_000,
+                            stdio: ['ignore', 'pipe', 'ignore'],
+                        }).trim();
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+                resolveRoot: (cwd) => {
+                    try {
+                        return execFileSync('git', ['-C', cwd, 'rev-parse', '--show-toplevel'], {
+                            encoding: 'utf8',
+                            timeout: 2_000,
+                            stdio: ['ignore', 'pipe', 'ignore'],
+                        }).trim();
+                    }
+                    catch {
+                        return null;
+                    }
+                },
+            }),
+        },
+        {
+            name: 'MCP SERVERS',
+            run: async () => probeMcpSafely(ctx),
+        },
+        {
+            name: 'CONFIG',
+            run: async () => probeConfig(ctx, {
+                existsSync,
+                readFileSync: (p, encoding) => readFileSync(p, encoding),
+            }),
+        },
+        {
+            name: 'SESSION',
+            run: async () => probeSession(ctx, {
+                existsSync,
+                statSync,
+                readFileSync: (p, encoding) => readFileSync(p, encoding),
+            }, {
+                now,
+                ...(options.liveSessionId ? { liveSessionId: options.liveSessionId } : {}),
+            }),
+        },
+        // α7 L11 (2026-05-27): DENIAL TRACKING probe. Reports the live
+        // session's denial pressure when the REPL adapter wired the
+        // tracker through `runDoctorCommand`; degrades к `skipped` for
+        // top-level `pugi doctor` calls outside the REPL.
+        {
+            name: 'DENIAL TRACKING',
+            run: async () => probeDenialTracking({
+                ...(options.denialTracking ? { tracker: options.denialTracking } : {}),
+            }),
+        },
+    ];
+    return probes;
+}
+/**
+ * Run the full doctor sweep + emit the output via the supplied
+ * writeOutput sink. Returns the report so REPL callers can route it
+ * к the Ink renderer instead of the plain-text fallback.
+ */
+export async function runDoctorCommand(ctx) {
+    const probeCtx = {
+        cwd: ctx.cwd,
+        home: ctx.home,
+        env: ctx.env,
+    };
+    const probes = buildDefaultProbes(probeCtx, {
+        ...(ctx.liveSessionId ? { liveSessionId: ctx.liveSessionId } : {}),
+        ...(ctx.denialTracking ? { denialTracking: ctx.denialTracking } : {}),
+    });
+    const report = await runProbes(probes);
+    // Defensive recompute: even though runProbes already computed the
+    // overall + counts, recomputing here documents the invariant for the
+    // reader and gives the JSON envelope a single source of truth.
+    const overall = computeOverall(report.probes);
+    const counts = countProbes(report.probes);
+    const envelope = {
+        command: 'doctor',
+        overall,
+        counts,
+        durationMs: report.durationMs,
+        probes: report.probes,
+        meta: {
+            cliVersion: PUGI_CLI_VERSION,
+            nodeVersion: process.version,
+            cwd: ctx.cwd,
+        },
+    };
+    const text = renderDoctorTable(envelope);
+    ctx.writeOutput(envelope, text);
+    process.exitCode = exitCodeFor(overall);
+    return { ...report, overall, counts };
+}
+/**
+ * Plain-text table renderer. Mirrors the layout from the leak-parity
+ * spec but is intentionally column-light (3 columns: NAME / STATUS /
+ * DETAIL) so it composes well in narrow terminals without dragging
+ * a layout library into the CLI hot path. The Ink TUI renderer in
+ * `tui/doctor-table.tsx` is the colour-aware variant used inside the
+ * REPL.
+ */
+export function renderDoctorTable(envelope) {
+    const NAME_WIDTH = Math.max('NAME'.length, ...envelope.probes.map((row) => row.name.length));
+    const STATUS_WIDTH = Math.max('STATUS'.length, ...envelope.probes.map((row) => row.status.length));
+    const lines = [];
+    lines.push('Pugi Doctor — environment health report');
+    lines.push('='.repeat(50));
+    lines.push('');
+    for (const row of envelope.probes) {
+        const namePart = row.name.padEnd(NAME_WIDTH, ' ');
+        const statusPart = row.status.toUpperCase().padEnd(STATUS_WIDTH, ' ');
+        const latencyPart = typeof row.latencyMs === 'number' ? ` (${row.latencyMs}ms)` : '';
+        lines.push(`${namePart}  ${statusPart}  ${row.detail}${latencyPart}`);
+        if (row.remediation && (row.status === 'warn' || row.status === 'error')) {
+            lines.push(`${' '.repeat(NAME_WIDTH + STATUS_WIDTH + 4)}→ ${row.remediation}`);
+        }
+    }
+    lines.push('');
+    const { ok, warn, error: errorCount, skipped } = envelope.counts;
+    const summary = envelope.overall === 'healthy'
+        ? 'HEALTHY'
+        : envelope.overall === 'warning'
+            ? 'WARNINGS'
+            : 'ERRORS';
+    lines.push(`${errorCount} error(s), ${warn} warning(s), ${ok} ok, ${skipped} skipped. Overall: ${summary}`);
+    lines.push(`CLI ${envelope.meta.cliVersion}  Node ${envelope.meta.nodeVersion}  cwd ${envelope.meta.cwd}`);
+    return lines.join('\n');
+}
+/**
+ * Wrap the MCP probe in a dynamic import + try/catch so a missing
+ * sibling L13 surface (or a schema mismatch in `core/mcp/registry`)
+ * degrades the row к `skipped` instead of breaking the entire sweep.
+ * The probe-runner already isolates throws into `error` rows; this
+ * wrapper additionally distinguishes "feature not available" from
+ * "feature crashed".
+ */
+async function probeMcpSafely(ctx) {
+    try {
+        const mod = await import('../../core/mcp/registry.js');
+        if (typeof mod.loadMcpRegistry !== 'function') {
+            return {
+                name: 'MCP SERVERS',
+                status: 'skipped',
+                detail: 'MCP integration not exported by this build',
+            };
+        }
+        return await probeMcp(ctx, {
+            loadRegistry: (cwd, options) => mod.loadMcpRegistry(cwd, { connect: options.connect ?? false }),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            name: 'MCP SERVERS',
+            status: 'skipped',
+            detail: 'MCP integration not available',
+            remediation: `Inspection failed: ${message}`,
+        };
+    }
+}
+/**
+ * Best-effort free-bytes lookup via `df -k <home>`. Parses the second
+ * line (header + one data row) and returns the `Available` column ×
+ * 1024. Throws on parse failure so the probe surfaces a `warn`
+ * instead of a misleading 0-bytes-free verdict.
+ *
+ * Exported for the spec so we can drive it through a stubbed
+ * execFileSync without spawning a real subprocess.
+ */
+export function getFreeBytesViaDf(home) {
+    const out = execFileSync('df', ['-k', home], {
+        encoding: 'utf8',
+        timeout: 2_000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return parseDfOutput(out);
+}
+/**
+ * Parse the textual output of `df -k`. Handles both BSD and GNU
+ * variants — both emit a `Available` column at index 3 of the data
+ * row, with one quirk: long device names wrap к the next line on
+ * GNU, so we collapse whitespace + tab newlines first.
+ */
+export function parseDfOutput(out) {
+    // Collapse multi-line device-name wraps into a single logical row.
+    const collapsed = out.replace(/\n\s+/g, ' ');
+    const lines = collapsed
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length < 2) {
+        throw new Error(`df output too short: ${JSON.stringify(out.slice(0, 64))}`);
+    }
+    const data = lines[1].split(/\s+/);
+    // Schema: Filesystem 1K-blocks Used Available Capacity Mounted-on
+    const availableField = data[3];
+    if (!availableField) {
+        throw new Error(`df output missing Available column: ${JSON.stringify(lines[1])}`);
+    }
+    const value = Number(availableField);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`df Available column not numeric: ${availableField}`);
+    }
+    return value * 1024;
+}
+/**
+ * Default home dir resolver. Centralised so the CLI handler can call
+ * `runDoctorCommand` without re-importing `os.homedir` everywhere.
+ */
+export function defaultHome() {
+    return homedir();
+}
+//# sourceMappingURL=doctor.js.map