@y4wee/nupo 0.1.0

package/dist/App.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { CliStartArgs } from './types/index.js';
+interface AppProps {
+    onExit: () => void;
+    startupArgs?: CliStartArgs;
+}
+export declare function App({ onExit, startupArgs }: AppProps): React.JSX.Element;
+export {};

package/dist/App.js

@@ -0,0 +1,109 @@
+import React, { useState, useMemo, useCallback, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { getPrimaryColor, getSecondaryColor, getTextColor, getCursorColor } from './types/index.js';
+import { useConfig } from './hooks/useConfig.js';
+import { useTerminalSize } from './hooks/useTerminalSize.js';
+import { Header } from './components/Header.js';
+import { ConfirmExit } from './components/ConfirmExit.js';
+import { HomeScreen } from './screens/HomeScreen.js';
+import { InitScreen } from './screens/InitScreen.js';
+import { OdooScreen } from './screens/OdooScreen.js';
+import { ConfigScreen } from './screens/ConfigScreen.js';
+import { IdeScreen } from './screens/IdeScreen.js';
+export function App({ onExit, startupArgs }) {
+    const { columns, rows } = useTerminalSize();
+    const { config, loading, refresh } = useConfig();
+    const [currentScreen, setCurrentScreen] = useState('home');
+    const [confirmExit, setConfirmExit] = useState(false);
+    const [confirmSelected, setConfirmSelected] = useState(1);
+    const [serviceRunning, setServiceRunning] = useState(false);
+    const [activeService, setActiveService] = useState(null);
+    // Reposition to top-left whenever the box height changes (service start/stop)
+    useEffect(() => {
+        process.stdout.write('\x1B[2J\x1B[H');
+    }, [serviceRunning]);
+    // Auto-navigate to odoo screen when CLI start args are present
+    useEffect(() => {
+        if (!loading && config?.initiated && startupArgs) {
+            setCurrentScreen('odoo');
+        }
+    }, [loading, config?.initiated, startupArgs]);
+    const primaryColor = getPrimaryColor(config);
+    const secondaryColor = getSecondaryColor(config);
+    const textColor = getTextColor(config);
+    const cursorColor = getCursorColor(config);
+    const options = useMemo(() => [
+        {
+            id: 'init',
+            label: 'Initialisation',
+            description: "Configure l'environnement nupo : vérifie Python, pip et le chemin vers le dépôt Odoo.",
+            screen: 'init',
+            visible: !config?.initiated,
+        },
+        {
+            id: 'odoo',
+            label: 'Odoo',
+            description: 'Accédez aux outils Odoo : démarrage, migration, gestion des modules.',
+            screen: 'odoo',
+            visible: config?.initiated === true,
+        },
+        {
+            id: 'ide',
+            label: 'IDE',
+            description: 'Ouvrir une version Odoo dans VS Code avec la configuration de débogage.',
+            screen: 'ide',
+            visible: config?.initiated === true,
+        },
+        {
+            id: 'config',
+            label: 'Paramètres',
+            description: 'Changer la configuration nupo : modifiez les paramètres de votre environnement.',
+            screen: 'config',
+            visible: config?.initiated === true,
+        },
+    ].filter(o => o.visible), [config]);
+    // Global input: handles Ctrl+C and confirm-exit dialog on all screens
+    useInput((char, key) => {
+        if (confirmExit) {
+            if (key.leftArrow)
+                setConfirmSelected(0);
+            if (key.rightArrow)
+                setConfirmSelected(1);
+            if (key.return)
+                confirmSelected === 0 ? onExit() : setConfirmExit(false);
+            if (key.escape || char === 'n') {
+                setConfirmExit(false);
+                setConfirmSelected(1);
+            }
+            if (char === 'o' || char === 'y')
+                onExit();
+            if (key.ctrl && char === 'c')
+                onExit();
+            return;
+        }
+        if (key.ctrl && char === 'c' && !serviceRunning) {
+            setConfirmExit(true);
+            setConfirmSelected(1);
+        }
+    });
+    const handleInitComplete = useCallback(() => {
+        void refresh();
+        setCurrentScreen('home');
+    }, [refresh]);
+    const termWidth = columns - 2;
+    const leftWidth = Math.floor(termWidth * 0.33);
+    if (loading) {
+        return (React.createElement(Box, { borderStyle: "round", borderColor: primaryColor, flexDirection: "column", width: termWidth },
+            React.createElement(Header, { activeService: activeService, serviceRunning: serviceRunning, primaryColor: primaryColor, secondaryColor: secondaryColor }),
+            React.createElement(Box, { paddingX: 3, paddingY: 2 },
+                React.createElement(Text, { color: textColor, dimColor: true }, "Chargement\u2026"))));
+    }
+    return (React.createElement(Box, { borderStyle: "round", borderColor: primaryColor, flexDirection: "column", width: termWidth, height: serviceRunning ? rows : undefined },
+        React.createElement(Header, { activeService: activeService, serviceRunning: serviceRunning, primaryColor: primaryColor, secondaryColor: secondaryColor }),
+        currentScreen === 'home' && (React.createElement(HomeScreen, { leftWidth: leftWidth, options: options, isActive: !confirmExit, primaryColor: primaryColor, secondaryColor: secondaryColor, textColor: textColor, cursorColor: cursorColor, onNavigate: screen => setCurrentScreen(screen) })),
+        currentScreen === 'init' && (React.createElement(InitScreen, { config: config, leftWidth: leftWidth, onComplete: handleInitComplete })),
+        currentScreen === 'odoo' && config && (React.createElement(OdooScreen, { leftWidth: leftWidth, config: config, onBack: () => setCurrentScreen('home'), onConfigChange: () => void refresh(), onServiceRunning: svc => { setServiceRunning(true); setActiveService(svc); }, onServiceStopped: () => { setServiceRunning(false); setActiveService(null); }, autoStart: startupArgs })),
+        currentScreen === 'ide' && config && (React.createElement(IdeScreen, { config: config, leftWidth: leftWidth, onBack: () => setCurrentScreen('home') })),
+        currentScreen === 'config' && config && (React.createElement(ConfigScreen, { config: config, leftWidth: leftWidth, onBack: () => setCurrentScreen('home'), onSaved: () => { void refresh(); setCurrentScreen('home'); } })),
+        React.createElement(ConfirmExit, { visible: confirmExit, selected: confirmSelected, textColor: textColor, cursorColor: cursorColor })));
+}

package/dist/__tests__/checks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/checks.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('node:child_process');
+import { execFile } from 'node:child_process';
+import { checkPython, checkPip } from '../services/checks.js';
+const mockExecFile = vi.mocked(execFile);
+function makeSuccess(stdout) {
+    return (_cmd, _args, cb) => {
+        cb(null, stdout, '');
+        return {};
+    };
+}
+function makeError(message) {
+    return (_cmd, _args, cb) => {
+        const err = Object.assign(new Error(message), { code: 'ENOENT' });
+        cb(err, '', '');
+        return {};
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('checkPython', () => {
+    it('returns ok=true with version when python3 succeeds', async () => {
+        mockExecFile.mockImplementationOnce(makeSuccess('Python 3.10.12'));
+        const result = await checkPython();
+        expect(result.ok).toBe(true);
+        expect(result.version).toBe('3.10.12');
+    });
+    it('falls back to python when python3 is not found', async () => {
+        mockExecFile
+            .mockImplementationOnce(makeError('spawn python3 ENOENT'))
+            .mockImplementationOnce(makeSuccess('Python 3.8.0'));
+        const result = await checkPython();
+        expect(result.ok).toBe(true);
+        expect(result.version).toBe('3.8.0');
+    });
+    it('returns ok=false when neither python3 nor python is found', async () => {
+        mockExecFile
+            .mockImplementationOnce(makeError('spawn python3 ENOENT'))
+            .mockImplementationOnce(makeError('spawn python ENOENT'));
+        const result = await checkPython();
+        expect(result.ok).toBe(false);
+        expect(result.error).toBeDefined();
+    });
+});
+describe('checkPip', () => {
+    it('returns ok=true with version when pip3 succeeds', async () => {
+        mockExecFile.mockImplementationOnce(makeSuccess('pip 23.0.1 from /usr/lib/python3/dist-packages/pip (python 3.11)'));
+        const result = await checkPip();
+        expect(result.ok).toBe(true);
+        expect(result.version).toBe('23.0.1');
+    });
+    it('falls back to pip when pip3 is not found', async () => {
+        mockExecFile
+            .mockImplementationOnce(makeError('spawn pip3 ENOENT'))
+            .mockImplementationOnce(makeSuccess('pip 22.0.4 from /usr/local/lib (python 3.9)'));
+        const result = await checkPip();
+        expect(result.ok).toBe(true);
+        expect(result.version).toBe('22.0.4');
+    });
+    it('returns ok=false when neither pip3 nor pip is found', async () => {
+        mockExecFile
+            .mockImplementationOnce(makeError('spawn pip3 ENOENT'))
+            .mockImplementationOnce(makeError('spawn pip ENOENT'));
+        const result = await checkPip();
+        expect(result.ok).toBe(false);
+    });
+});

package/dist/__tests__/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/config.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { configExists, readConfig, writeConfig, patchConfig, getConfigPath, } from '../services/config.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+let tmpDir;
+const BASE_CONFIG = {
+    initiated: false,
+    python_installed: false,
+    pip_installed: false,
+    odoo_path_repo: '',
+    odoo_versions: {},
+};
+describe('config service', () => {
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'nupo-test-'));
+        process.env['NUPO_CONFIG_DIR'] = tmpDir;
+    });
+    afterEach(async () => {
+        delete process.env['NUPO_CONFIG_DIR'];
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('configExists: false when file is absent', async () => {
+        expect(await configExists()).toBe(false);
+    });
+    it('configExists: true after writeConfig', async () => {
+        await writeConfig({ ...BASE_CONFIG, initiated: true, python_installed: true, pip_installed: true, odoo_path_repo: '/tmp/odoo' });
+        expect(await configExists()).toBe(true);
+    });
+    it('readConfig: returns DEFAULT_CONFIG when file is absent', async () => {
+        const cfg = await readConfig();
+        expect(cfg).toEqual(DEFAULT_CONFIG);
+    });
+    it('readConfig: parses existing JSON', async () => {
+        const saved = {
+            initiated: true,
+            python_installed: true,
+            pip_installed: false,
+            odoo_path_repo: '/home/user/odoo',
+            odoo_versions: { '17.0': { branch: '17.0', path: '/home/user/odoo/17.0' } },
+        };
+        await writeConfig(saved);
+        const cfg = await readConfig();
+        expect(cfg).toEqual(saved);
+    });
+    it('writeConfig: creates directory if absent and writes valid JSON', async () => {
+        await writeConfig(BASE_CONFIG);
+        const raw = await readFile(getConfigPath(), 'utf-8');
+        expect(JSON.parse(raw)).toEqual(BASE_CONFIG);
+    });
+    it('patchConfig: merges without overwriting other keys', async () => {
+        await writeConfig({ ...BASE_CONFIG, python_installed: true });
+        await patchConfig({ pip_installed: true });
+        const cfg = await readConfig();
+        expect(cfg.python_installed).toBe(true);
+        expect(cfg.pip_installed).toBe(true);
+        expect(cfg.initiated).toBe(false);
+        expect(cfg.odoo_versions).toEqual({});
+    });
+});

package/dist/components/ConfirmExit.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface ConfirmExitProps {
+    visible: boolean;
+    selected: number;
+    textColor?: string;
+    cursorColor?: string;
+}
+export declare function ConfirmExit({ visible, selected, textColor, cursorColor }: ConfirmExitProps): React.JSX.Element | null;
+export {};

package/dist/components/ConfirmExit.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export function ConfirmExit({ visible, selected, textColor = '#848484', cursorColor = 'cyan' }) {
+    if (!visible)
+        return null;
+    return (React.createElement(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 0, marginX: 2, marginBottom: 1, flexDirection: "row", justifyContent: "space-between", alignItems: "center" },
+        React.createElement(Text, { color: "yellow" }, "Voulez-vous vraiment quitter nupo ?"),
+        React.createElement(Box, { flexDirection: "row", gap: 2 },
+            React.createElement(Text, { color: selected === 0 ? 'black' : 'white', backgroundColor: selected === 0 ? 'yellow' : undefined, bold: selected === 0 }, ' Oui '),
+            React.createElement(Text, { color: selected === 1 ? 'black' : 'white', backgroundColor: selected === 1 ? cursorColor : undefined, bold: selected === 1 }, ' Non ')),
+        React.createElement(Text, { color: textColor, dimColor: true }, '◀▶ choisir  ·  ↵ confirmer')));
+}

package/dist/components/ErrorPanel.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { AnyStep } from '../types/index.js';
+interface ErrorPanelProps {
+    steps: AnyStep[];
+}
+export declare function ErrorPanel({ steps }: ErrorPanelProps): React.JSX.Element | null;
+export {};

package/dist/components/ErrorPanel.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export function ErrorPanel({ steps }) {
+    const errorStep = steps.find(s => s.status === 'error');
+    if (!errorStep)
+        return null;
+    return (React.createElement(Box, { borderStyle: "single", borderColor: "red", paddingX: 2, paddingY: 0, borderTop: true, borderBottom: false, borderLeft: false, borderRight: false },
+        React.createElement(Text, { color: "red" },
+            '✗ ',
+            errorStep.label,
+            errorStep.errorMessage ? ` : ${errorStep.errorMessage}` : '')));
+}

package/dist/components/Header.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { OdooServiceConfig } from '../types/index.js';
+interface HeaderProps {
+    activeService?: OdooServiceConfig | null;
+    serviceRunning?: boolean;
+    primaryColor?: string;
+    secondaryColor?: string;
+}
+export declare function Header({ activeService, serviceRunning, primaryColor, secondaryColor }: HeaderProps): React.JSX.Element;
+export {};

package/dist/components/Header.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+const { version } = _require('../../package.json');
+export function Header({ activeService, serviceRunning, primaryColor = '#9F0C58', secondaryColor = '#E79439' }) {
+    return (React.createElement(Box, { paddingX: 1, borderStyle: "single", borderColor: "gray", borderTop: false, borderLeft: false, borderRight: false, borderBottom: true, flexDirection: "row", gap: 1 },
+        React.createElement(Text, { color: primaryColor, bold: true }, "nupO"),
+        React.createElement(Text, { color: secondaryColor, dimColor: true },
+            "v",
+            version),
+        activeService && (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: "white", dimColor: true }, "\u00B7"),
+            React.createElement(Text, { color: "yellow", bold: true }, activeService.name),
+            React.createElement(Text, { color: "white", dimColor: true }, activeService.branch),
+            React.createElement(Text, { color: serviceRunning ? 'green' : 'red' }, serviceRunning ? '● en cours' : '■ arrêté')))));
+}

package/dist/components/LeftPanel.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+interface LeftPanelProps {
+    width: number;
+    serviceLabel?: string;
+    primaryColor?: string;
+    textColor?: string;
+}
+export declare function LeftPanel({ width, serviceLabel, primaryColor, textColor }: LeftPanelProps): React.JSX.Element;
+export {};

package/dist/components/LeftPanel.js

@@ -0,0 +1,31 @@
+import React, { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+const LOGO = `
+  ███
+ █   █
+█     █
+█     █     █
+      █     █
+       █   █
+        ███
+`;
+const WELCOME = "Bienvenue\nNuprodien";
+export function LeftPanel({ width, serviceLabel, primaryColor = '#9F0C58', textColor = '#848484' }) {
+    const [typedText, setTypedText] = useState("");
+    useEffect(() => {
+        let i = 0;
+        const id = setInterval(() => {
+            i++;
+            setTypedText(WELCOME.slice(0, i));
+            if (i >= WELCOME.length)
+                clearInterval(id);
+        }, 60);
+        return () => clearInterval(id);
+    }, []);
+    return (React.createElement(Box, { width: width, flexGrow: 0, flexShrink: 0, flexDirection: "column", paddingX: 2, paddingY: 2, gap: 2, borderStyle: "single", borderColor: "gray", borderTop: false, borderBottom: false, borderLeft: false, borderRight: true },
+        React.createElement(Box, { flexDirection: "column", alignItems: "center" },
+            React.createElement(Text, { color: primaryColor }, LOGO)),
+        serviceLabel && (React.createElement(Box, { flexDirection: "column", gap: 0 },
+            React.createElement(Text, { color: textColor, dimColor: true }, "Service"),
+            React.createElement(Text, { color: "yellow", bold: true }, serviceLabel)))));
+}

package/dist/components/OptionsPanel.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { MenuOption } from '../types/index.js';
+interface OptionsPanelProps {
+    options: MenuOption[];
+    selected: number;
+    secondaryColor?: string;
+    textColor?: string;
+    cursorColor?: string;
+}
+export declare function OptionsPanel({ options, selected, secondaryColor, textColor, cursorColor }: OptionsPanelProps): React.JSX.Element;
+export {};

package/dist/components/OptionsPanel.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export function OptionsPanel({ options, selected, secondaryColor, textColor = '#848484', cursorColor = 'cyan' }) {
+    const current = options[selected];
+    if (options.length === 0) {
+        return (React.createElement(Box, { flexGrow: 1, flexDirection: "column", paddingX: 3, paddingY: 2 },
+            React.createElement(Text, { color: textColor, dimColor: true }, "Aucune option disponible.")));
+    }
+    return (React.createElement(Box, { flexGrow: 1, flexDirection: "column", paddingX: 3, paddingY: 2, gap: 1 },
+        React.createElement(Box, { flexDirection: "column", gap: 0 }, options.map((opt, i) => {
+            const isSelected = i === selected;
+            return (React.createElement(Text, { key: opt.id, color: isSelected ? 'black' : 'white', backgroundColor: isSelected ? cursorColor : undefined, bold: isSelected }, ` ${isSelected ? '▶' : ' '} ${opt.label}`));
+        })),
+        React.createElement(Box, null,
+            React.createElement(Text, { color: textColor, dimColor: true }, '↑↓ naviguer  ·  ↵ sélectionner')),
+        React.createElement(Box, { borderStyle: "round", borderColor: textColor, paddingX: 1, paddingY: 0 },
+            React.createElement(Text, { color: textColor, wrap: "wrap" }, current?.description ?? ''))));
+}

package/dist/components/PathInput.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface PathInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    placeholder?: string;
+    focus?: boolean;
+    textColor?: string;
+}
+export declare function PathInput({ value, onChange, onSubmit, placeholder, focus, textColor, }: PathInputProps): React.JSX.Element;

package/dist/components/PathInput.js

@@ -0,0 +1,133 @@
+import React, { useState, useRef } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+const MAX_VISIBLE = 6;
+function expandHome(p) {
+    if (p === '~' || p.startsWith('~/'))
+        return homedir() + p.slice(1);
+    return p;
+}
+function commonPrefix(strs) {
+    if (!strs.length)
+        return '';
+    let pre = strs[0];
+    for (const s of strs.slice(1)) {
+        while (!s.startsWith(pre))
+            pre = pre.slice(0, -1);
+    }
+    return pre;
+}
+async function computeCompletions(input) {
+    const expanded = expandHome(input);
+    let searchDir;
+    let partial;
+    let prefix; // part of original input kept verbatim before the partial token
+    if (expanded.endsWith('/')) {
+        searchDir = expanded || '.';
+        partial = '';
+        prefix = input;
+    }
+    else {
+        const lastSlash = expanded.lastIndexOf('/');
+        if (lastSlash === -1) {
+            searchDir = process.cwd();
+            partial = expanded;
+            prefix = '';
+        }
+        else {
+            searchDir = expanded.slice(0, lastSlash + 1);
+            partial = expanded.slice(lastSlash + 1);
+            const origSlash = input.lastIndexOf('/');
+            prefix = origSlash === -1 ? '' : input.slice(0, origSlash + 1);
+        }
+    }
+    try {
+        const entries = await readdir(searchDir || '.');
+        const matches = entries.filter(e => e.startsWith(partial));
+        const results = [];
+        for (const match of matches) {
+            let suffix = '';
+            try {
+                const s = await stat(join(searchDir || '.', match));
+                if (s.isDirectory())
+                    suffix = '/';
+            }
+            catch { }
+            results.push(prefix + match + suffix);
+        }
+        return results.sort();
+    }
+    catch {
+        return [];
+    }
+}
+export function PathInput({ value, onChange, onSubmit, placeholder, focus = true, textColor = '#848484', }) {
+    const [completions, setCompletions] = useState(null);
+    // Refs for fresh values inside async callback
+    const genRef = useRef(0);
+    const valueRef = useRef(value);
+    const completionsRef = useRef(completions);
+    const onChangeRef = useRef(onChange);
+    valueRef.current = value;
+    completionsRef.current = completions;
+    onChangeRef.current = onChange;
+    const cancelCompletions = () => {
+        genRef.current++;
+        setCompletions(null);
+    };
+    useInput((_char, key) => {
+        if (!key.tab) {
+            cancelCompletions();
+            return;
+        }
+        const gen = ++genRef.current;
+        const cur = completionsRef.current;
+        // Already have completions: cycle to next
+        if (cur && cur.items.length > 0) {
+            const next = (cur.index + 1) % cur.items.length;
+            setCompletions({ ...cur, index: next });
+            onChangeRef.current(cur.items[next]);
+            return;
+        }
+        // Compute new completions
+        void computeCompletions(valueRef.current).then(items => {
+            if (gen !== genRef.current)
+                return; // cancelled by user input
+            if (items.length === 0)
+                return;
+            if (items.length === 1) {
+                if (items[0] !== valueRef.current)
+                    onChangeRef.current(items[0]);
+                setCompletions({ items, index: 0 });
+                return;
+            }
+            // Multiple: complete to common prefix first, then cycle on next TABs
+            const cp = commonPrefix(items);
+            if (cp && cp !== valueRef.current) {
+                onChangeRef.current(cp);
+                setCompletions({ items, index: -1 });
+            }
+            else {
+                // Already at common prefix: start cycling
+                onChangeRef.current(items[0]);
+                setCompletions({ items, index: 0 });
+            }
+        });
+    }, { isActive: focus });
+    const showList = completions !== null && completions.items.length > 1;
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(TextInput, { value: value, onChange: v => {
+                cancelCompletions();
+                onChange(v);
+            }, onSubmit: onSubmit, placeholder: placeholder, focus: focus }),
+        showList && (React.createElement(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0 },
+            completions.items.slice(0, MAX_VISIBLE).map((item, i) => {
+                const active = i === completions.index;
+                return (React.createElement(Text, { key: item, color: active ? 'cyan' : 'gray', bold: active, dimColor: !active }, active ? `▶ ${item}` : `  ${item}`));
+            }),
+            completions.items.length > MAX_VISIBLE && (React.createElement(Text, { color: textColor, dimColor: true }, `  … ${completions.items.length - MAX_VISIBLE} autre(s)`)),
+            React.createElement(Text, { color: textColor, dimColor: true }, '  ↹ suivant · ↵ valider')))));
+}

package/dist/components/ProgressBar.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function ProgressBar({ percent, textColor }: {
+    percent: number;
+    textColor?: string;
+}): React.JSX.Element;

package/dist/components/ProgressBar.js

@@ -0,0 +1,21 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+const BAR_WIDTH = 50;
+export function ProgressBar({ percent, textColor = '#848484' }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setFrame(f => f + 1), 150);
+        return () => clearInterval(id);
+    }, []);
+    const pos = Math.min(Math.round((percent / 100) * (BAR_WIDTH - 1)), BAR_WIDTH - 1);
+    const pacman = frame % 2 === 0 ? 'ᗧ' : '○';
+    const eaten = pos;
+    const remaining = BAR_WIDTH - 1 - pos;
+    return (React.createElement(Box, null,
+        React.createElement(Text, null,
+            React.createElement(Text, { color: "yellow" },
+                '─'.repeat(eaten),
+                pacman),
+            React.createElement(Text, { color: textColor, dimColor: true }, '·'.repeat(remaining)),
+            ` ${String(percent).padStart(3)}%`)));
+}

package/dist/components/StepsPanel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { AnyStep } from '../types/index.js';
+interface StepsPanelProps {
+    steps: AnyStep[];
+    textColor?: string;
+}
+export declare function StepsPanel({ steps, textColor }: StepsPanelProps): React.JSX.Element | null;
+export {};

package/dist/components/StepsPanel.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+const STATUS_ICON = {
+    pending: '○',
+    running: '⟳',
+    success: '✓',
+    error: '✗',
+};
+const STATUS_COLOR = {
+    pending: 'gray',
+    running: 'yellow',
+    success: 'green',
+    error: 'red',
+};
+export function StepsPanel({ steps, textColor = '#848484' }) {
+    if (steps.length === 0)
+        return null;
+    return (React.createElement(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, paddingX: 2, paddingY: 0 }, steps.map(step => (React.createElement(Box, { key: step.id, flexDirection: "row", gap: 1 },
+        React.createElement(Text, { color: STATUS_COLOR[step.status] }, STATUS_ICON[step.status]),
+        React.createElement(Text, { color: "white" }, step.label),
+        step.status === 'success' && step.errorMessage && (React.createElement(Text, { color: textColor, dimColor: true },
+            '  ',
+            step.errorMessage)))))));
+}

package/dist/hooks/useConfig.d.ts

@@ -0,0 +1,8 @@
+import { NupoConfig } from '../types/index.js';
+export interface UseConfigResult {
+    config: NupoConfig | null;
+    loading: boolean;
+    patch: (partial: Partial<NupoConfig>) => Promise<void>;
+    refresh: () => Promise<void>;
+}
+export declare function useConfig(): UseConfigResult;

package/dist/hooks/useConfig.js

@@ -0,0 +1,26 @@
+import { useState, useEffect, useCallback } from 'react';
+import { readConfig, patchConfig as patchConfigService, configExists, } from '../services/config.js';
+export function useConfig() {
+    const [config, setConfig] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const load = useCallback(async () => {
+        setLoading(true);
+        const exists = await configExists();
+        if (exists) {
+            const c = await readConfig();
+            setConfig(c);
+        }
+        else {
+            setConfig(null);
+        }
+        setLoading(false);
+    }, []);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const patch = useCallback(async (partial) => {
+        await patchConfigService(partial);
+        await load();
+    }, [load]);
+    return { config, loading, patch, refresh: load };
+}