@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/tui/onboarding-wizard.js

@@ -0,0 +1,240 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * — Onboarding Ink wizard.
+ *
+ * Six-screen interactive walk:
+ *
+ *  1. Welcome + auth status        (single Enter to continue)
+ *  2. Default permission mode      (4-row picker)
+ *  3. Output style preset          (5-row picker)
+ *  4. MCP server pointer           (informational, Enter to continue)
+ *  5. Telemetry consent            (3-row picker)
+ *  6. Recap card                   (Enter to commit + exit)
+ *
+ * Driven entirely by Ink's `useInput`. The component does NOT perform
+ * any fs writes — it resolves the verdict back to the caller
+ * (`runOnboardingCommand`), which translates verdicts into L6 / L18 /
+ * telemetry-state mutations. Single source of truth: the runner.
+ *
+ * Each picker step pre-selects the CURRENT persisted value (from the
+ * snapshot passed in props) so pressing Enter on Step 2/3/5 keeps the
+ * current value — that is the idempotency contract.
+ *
+ * Cancellation:
+ *  - Esc / Ctrl-C at any step → verdict.cancelled = true, the runner
+ *    skips ALL writes (including the marker touch) so the next bare
+ *    `pugi` invocation still surfaces the first-run hint.
+ *
+ * Keystrokes:
+ *  - ↑/↓ or j/k — move selection in pickers.
+ *  - Enter     — confirm step (keep current = pass through; new pick
+ *                 = update verdict for that tier).
+ *  - 's'       — skip current step explicitly (verdict slot stays null).
+ *  - Esc / 'q' — cancel the wizard.
+ */
+import { useState } from 'react';
+import { Box, Text, render, useApp, useInput } from 'ink';
+import { PERMISSION_MODES, PERMISSION_MODE_GLOSS, } from '../core/permissions/index.js';
+import { OUTPUT_STYLES, OUTPUT_STYLE_SLUGS, } from '../core/output-style/presets.js';
+import { TELEMETRY_CHOICES, } from '../core/onboarding/telemetry-state.js';
+const EMPTY_DRAFT = {
+    permissionMode: null,
+    outputStyle: null,
+    telemetry: null,
+};
+/**
+ * Lookup the snapshot value's index within the picker rows so the
+ * initial cursor sits on the current value. Returns 0 (safe default)
+ * when the snapshot value is outside the closed list — should never
+ * happen given the type guards in the state modules, but the index
+ * fallback keeps Ink from crashing on a malformed config.
+ */
+function indexOf(rows, value) {
+    const idx = rows.indexOf(value);
+    return idx === -1 ? 0 : idx;
+}
+/**
+ * The wizard component. Pure: no fs, no env, no network. Verdicts
+ * flow up via `onComplete`; the caller owns the writes.
+ */
+export function OnboardingWizard(props) {
+    const { snapshot, onComplete } = props;
+    const [step, setStep] = useState(1);
+    const [permissionIdx, setPermissionIdx] = useState(indexOf(PERMISSION_MODES, snapshot.permissionMode));
+    const [styleIdx, setStyleIdx] = useState(indexOf(OUTPUT_STYLE_SLUGS, snapshot.outputStyle));
+    const [telemetryIdx, setTelemetryIdx] = useState(indexOf(TELEMETRY_CHOICES, snapshot.telemetry));
+    const [draft, setDraft] = useState(EMPTY_DRAFT);
+    const finish = (final, cancelled) => {
+        onComplete({
+            permissionMode: final.permissionMode,
+            outputStyle: final.outputStyle,
+            telemetry: final.telemetry,
+            cancelled,
+        });
+    };
+    useInput((input, key) => {
+        // Universal cancel.
+        if (key.escape || (key.ctrl && input === 'c')) {
+            finish(EMPTY_DRAFT, true);
+            return;
+        }
+        // Universal skip — Enter on a picker means "keep current"; explicit
+        // 's' makes the skip intent obvious in the recap.
+        const isAdvance = key.return;
+        const moveUp = key.upArrow || input === 'k';
+        const moveDown = key.downArrow || input === 'j';
+        const explicitSkip = input === 's';
+        switch (step) {
+            case 1: {
+                if (isAdvance)
+                    setStep(2);
+                return;
+            }
+            case 2: {
+                if (moveUp) {
+                    setPermissionIdx((i) => (i === 0 ? PERMISSION_MODES.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setPermissionIdx((i) => (i === PERMISSION_MODES.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = PERMISSION_MODES[permissionIdx];
+                    const verdict = explicitSkip || picked === snapshot.permissionMode ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, permissionMode: verdict }));
+                    setStep(3);
+                    return;
+                }
+                return;
+            }
+            case 3: {
+                if (moveUp) {
+                    setStyleIdx((i) => (i === 0 ? OUTPUT_STYLE_SLUGS.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setStyleIdx((i) => (i === OUTPUT_STYLE_SLUGS.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = OUTPUT_STYLE_SLUGS[styleIdx];
+                    const verdict = explicitSkip || picked === snapshot.outputStyle ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, outputStyle: verdict }));
+                    setStep(4);
+                    return;
+                }
+                return;
+            }
+            case 4: {
+                if (isAdvance)
+                    setStep(5);
+                return;
+            }
+            case 5: {
+                if (moveUp) {
+                    setTelemetryIdx((i) => (i === 0 ? TELEMETRY_CHOICES.length - 1 : i - 1));
+                    return;
+                }
+                if (moveDown) {
+                    setTelemetryIdx((i) => (i === TELEMETRY_CHOICES.length - 1 ? 0 : i + 1));
+                    return;
+                }
+                if (isAdvance || explicitSkip) {
+                    const picked = TELEMETRY_CHOICES[telemetryIdx];
+                    const verdict = explicitSkip || picked === snapshot.telemetry ? null : picked ?? null;
+                    setDraft((d) => ({ ...d, telemetry: verdict }));
+                    setStep(6);
+                    return;
+                }
+                return;
+            }
+            case 6: {
+                if (isAdvance)
+                    finish(draft, false);
+                return;
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(StepHeader, { step: step }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [step === 1 && _jsx(WelcomeStep, { snapshot: snapshot }), step === 2 && (_jsx(ModeStep, { current: snapshot.permissionMode, selectedIdx: permissionIdx })), step === 3 && (_jsx(StyleStep, { current: snapshot.outputStyle, currentSource: snapshot.outputStyleSource, selectedIdx: styleIdx })), step === 4 && _jsx(McpStep, {}), step === 5 && (_jsx(TelemetryStep, { current: snapshot.telemetry, selectedIdx: telemetryIdx })), step === 6 && _jsx(RecapStep, { snapshot: snapshot, draft: draft })] }), _jsx(FooterHints, { step: step })] }));
+}
+function StepHeader({ step }) {
+    const titles = {
+        1: 'Welcome to Pugi',
+        2: 'Step 2 / 5 — Default permission mode',
+        3: 'Step 3 / 5 — Output style',
+        4: 'Step 4 / 5 — MCP servers',
+        5: 'Step 5 / 5 — Telemetry consent',
+        6: 'Setup complete',
+    };
+    return (_jsx(Text, { bold: true, color: "cyan", children: titles[step] }));
+}
+function WelcomeStep({ snapshot }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Brief it. It ships." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: snapshot.authPresent
+                        ? 'You are signed in. The wizard configures local defaults; values persist to ~/.pugi/config.json.'
+                        : 'You are NOT signed in. The wizard still configures local defaults, but you should run `pugi login` after.' }) })] }));
+}
+function ModeStep({ current, selectedIdx, }) {
+    return (_jsx(Box, { flexDirection: "column", children: PERMISSION_MODES.map((mode, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: mode === current, title: mode, gloss: PERMISSION_MODE_GLOSS[mode] }, mode))) }));
+}
+function StyleStep({ current, currentSource, selectedIdx, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [OUTPUT_STYLE_SLUGS.map((slug, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: slug === current, title: slug, gloss: OUTPUT_STYLES[slug].gloss }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: currentSource === 'workspace'
+                        ? 'Active style is currently a workspace override. The wizard writes the user-tier default.'
+                        : `Active source: ${currentSource}.` }) })] }));
+}
+function McpStep() {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "MCP servers extend Pugi with extra tools (filesystem, browser, custom APIs)." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Add one with:" }) }), _jsx(Text, { children: ' pugi mcp add <name> <command>' }), _jsx(Text, { children: ' pugi mcp list' }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "You can skip for now and add servers later." }) })] }));
+}
+function TelemetryStep({ current, selectedIdx, }) {
+    const gloss = {
+        off: 'No telemetry of any kind.',
+        anonymous: 'Counts + error categories only; no payloads.',
+        community: 'Anonymous + opt-in usage panels.',
+    };
+    return (_jsx(Box, { flexDirection: "column", children: TELEMETRY_CHOICES.map((choice, idx) => (_jsx(PickerRow, { isSelected: idx === selectedIdx, isCurrent: choice === current, title: choice, gloss: gloss[choice] }, choice))) }));
+}
+function RecapStep({ snapshot, draft, }) {
+    const finalMode = draft.permissionMode ?? snapshot.permissionMode;
+    const finalStyle = draft.outputStyle ?? snapshot.outputStyle;
+    const finalTelemetry = draft.telemetry ?? snapshot.telemetry;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: ` Permission mode: ${finalMode}${draft.permissionMode === null ? ' (unchanged)' : ''}` }), _jsx(Text, { children: ` Output style:   ${finalStyle}${draft.outputStyle === null ? ' (unchanged)' : ''}` }), _jsx(Text, { children: ` Telemetry:      ${finalTelemetry}${draft.telemetry === null ? ' (unchanged)' : ''}` }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to write defaults + exit. Esc to cancel without saving." }) })] }));
+}
+function PickerRow({ isSelected, isCurrent, title, gloss, }) {
+    const indicator = isSelected ? '▸ ' : ' ';
+    const currentTag = isCurrent ? ' [current]' : '';
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, title.padEnd(18, ' ')] }), _jsx(Text, { dimColor: true, children: `${gloss}${currentTag}` })] }));
+}
+function FooterHints({ step }) {
+    const hint = step === 1 || step === 4
+        ? 'Enter continue  Esc cancel'
+        : step === 6
+            ? 'Enter commit + exit  Esc cancel'
+            : '↑/↓ select  Enter confirm  s skip  Esc cancel';
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: hint }) }));
+}
+/**
+ * Mount the wizard, await the operator's verdict, unmount Ink, return
+ * the verdict to the runner. Wrapped in a `useApp` consumer so we can
+ * call `exit()` and let `waitUntilExit()` resolve cleanly.
+ */
+export async function renderOnboardingWizard(opts) {
+    return new Promise((resolvePromise) => {
+        let resolved = false;
+        const handleComplete = (verdict) => {
+            if (resolved)
+                return;
+            resolved = true;
+            app.unmount();
+            resolvePromise(verdict);
+        };
+        const Wrapper = () => {
+            const { exit } = useApp();
+            return (_jsx(OnboardingWizard, { snapshot: opts.snapshot, onComplete: (verdict) => {
+                    handleComplete(verdict);
+                    exit();
+                } }));
+        };
+        const app = render(_jsx(Wrapper, {}));
+    });
+}
+//# sourceMappingURL=onboarding-wizard.js.map

package/dist/tui/permissions-picker.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { PERMISSION_MODES, PERMISSION_MODE_GLOSS, } from '../core/permissions/index.js';
+/**
+ * Build the rendered rows from the canonical mode list. We map the
+ * 1-line gloss → row hint so `/permissions` and the picker stay in
+ * sync — a change to `PERMISSION_MODE_GLOSS` shows up here too.
+ */
+const ITEMS = PERMISSION_MODES.map((mode) => ({
+    mode,
+    title: titleCase(mode),
+    hint: PERMISSION_MODE_GLOSS[mode],
+}));
+function titleCase(mode) {
+    return mode.charAt(0).toUpperCase() + mode.slice(1);
+}
+/**
+ * Resolve the initial cursor — prefer the explicit `initialIndex`
+ * (spec / test) when provided, otherwise highlight the row matching
+ * the active mode so the operator opens the picker with their
+ * current selection focused.
+ */
+function resolveInitialIndex(currentMode, override) {
+    if (typeof override === 'number') {
+        return Math.min(Math.max(override, 0), ITEMS.length - 1);
+    }
+    const idx = ITEMS.findIndex((item) => item.mode === currentMode);
+    return idx >= 0 ? idx : 0;
+}
+export function PermissionsPicker(props) {
+    const [index, setIndex] = useState(resolveInitialIndex(props.currentMode, props.initialIndex));
+    useInput((input, key) => {
+        if (key.upArrow || input === 'k') {
+            setIndex((current) => (current === 0 ? ITEMS.length - 1 : current - 1));
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setIndex((current) => (current === ITEMS.length - 1 ? 0 : current + 1));
+            return;
+        }
+        if (key.return) {
+            const selected = ITEMS[index];
+            if (selected)
+                props.onSelect(selected.mode);
+            return;
+        }
+        if (key.escape || input === 'q') {
+            props.onCancel();
+            return;
+        }
+        // : number shortcuts mirror the canonical 6-mode order.
+        // Operators coming from the upstream tool reach the same mode with the
+        // same digit (1=default, 2=acceptEdits, …, 6=bypassPermissions).
+        if (input === '1')
+            props.onSelect('default');
+        if (input === '2')
+            props.onSelect('acceptEdits');
+        if (input === '3')
+            props.onSelect('plan');
+        if (input === '4')
+            props.onSelect('auto');
+        if (input === '5')
+            props.onSelect('dontAsk');
+        if (input === '6')
+            props.onSelect('bypassPermissions');
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Permission mode" }), _jsx(Text, { dimColor: true, children: `  (current: ${props.currentMode} — ${props.sourceLabel})` })] }), props.firstRun ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "First time? Mode = Ask \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E. Use /permissions \u043A change later." }) })) : null, _jsx(Box, { marginTop: 1, flexDirection: "column", children: ITEMS.map((item, itemIndex) => {
+                    const isSelected = itemIndex === index;
+                    const isCurrent = item.mode === props.currentMode;
+                    return (_jsx(PickerRow, { isSelected: isSelected, isCurrent: isCurrent, title: item.title, hint: item.hint }, item.mode));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '↑/↓ select  Enter confirm  Esc cancel' }) })] }));
+}
+function PickerRow({ isSelected, isCurrent, title, hint, }) {
+    // Arrow glyph + padded title so highlighted and dim rows share
+    // column alignment. A trailing ` ●` marks the currently-effective
+    // mode (separate from cursor focus) so an operator instantly sees
+    // which row is "what I have now" vs "what I'm hovering".
+    const indicator = isSelected ? '▸ ' : ' ';
+    // : longest title is `BypassPermissions` (17 chars). Bump the
+    // pad column так the gloss column stays aligned across all 6 rows.
+    const padded = title.padEnd(18, ' ');
+    const currentMarker = isCurrent ? ' ●' : ' ';
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, padded] }), _jsx(Text, { color: isCurrent ? 'green' : undefined, children: currentMarker }), _jsx(Text, { dimColor: true, children: ` ${hint}` })] }));
+}
+//# sourceMappingURL=permissions-picker.js.map

package/dist/tui/render.js

@@ -2,6 +2,7 @@ import React from 'react';
 import { render } from 'ink';
 import { DeviceFlow } from './device-flow.js';
 import { LoginPicker } from './login-picker.js';
+import { PermissionsPicker } from './permissions-picker.js';
 import { Splash } from './splash.js';
 import { collectSplashData } from './splash-data.js';
 /**
@@ -25,7 +26,7 @@ export async function renderSplash(cliVersion) {
  * Sentinel thrown when the user dismisses the login picker via Esc
  * or `q`. The CLI dispatcher catches it, prints a one-line abort
  * message, and exits 130 (the standard exit code for SIGINT-style
- * user cancellations — matches gh CLI, codex, claude-code).
+ * user cancellations — matches gh CLI and peer CLIs).
  */
 export class LoginCancelledError extends Error {
     constructor() {
@@ -66,6 +67,40 @@ export function renderLoginPicker(apiUrl) {
         }));
     });
 }
+/**
+ * Sentinel thrown when the operator dismisses the permissions picker
+ * via Esc / q. Mirrors `LoginCancelledError` — the host catches and
+ * prints a one-line abort message; no mode flip lands.
+ */
+export class PermissionsPickerCancelledError extends Error {
+    constructor() {
+        super('Permissions picker cancelled');
+        this.name = 'PermissionsPickerCancelledError';
+    }
+}
+export function renderPermissionsPicker(options) {
+    return new Promise((resolveMode, rejectMode) => {
+        let settled = false;
+        const finish = (cb) => {
+            if (settled)
+                return;
+            settled = true;
+            instance.unmount();
+            setImmediate(cb);
+        };
+        const instance = render(React.createElement(PermissionsPicker, {
+            currentMode: options.currentMode,
+            sourceLabel: options.sourceLabel,
+            firstRun: options.firstRun ?? false,
+            onSelect: (mode) => {
+                finish(() => resolveMode(mode));
+            },
+            onCancel: () => {
+                finish(() => rejectMode(new PermissionsPickerCancelledError()));
+            },
+        }));
+    });
+}
 /**
  * Mount `<DeviceFlow />` on a TTY and return a handle the host uses to
  * drive the frame. Mirrors `renderLoginPicker`'s lifecycle: we