mikrojs 0.0.0 → 0.0.8

package/dist/cli/lib/serial/replStateMachine.js

@@ -0,0 +1,657 @@
+import { appendFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { EMPTY, merge, Subject, timer } from 'rxjs';
+import { catchError, filter, first, ignoreElements, map, scan, shareReplay, startWith, switchMap, takeUntil, } from 'rxjs/operators';
+import { getMikroDir } from '../projectRoot.js';
+import { isIncomplete } from '../protocol.js';
+// ── Constants ──────────────────────────────────────────────
+/** All available slash commands */
+const SLASH_COMMANDS = [
+    '/help',
+    '/env',
+    '/mem',
+    '/info',
+    '/gc',
+    '/pause',
+    '/resume',
+    '/time',
+    '/depth',
+    '/hidden',
+    '/ls',
+    '/cat',
+    '/rm',
+    '/df',
+    '/du',
+    '/exit',
+];
+/** Context hints matched against the current input. First match wins. */
+const CONTEXT_HINTS = [
+    { pattern: /^console\.\s*$/, hint: 'console.log()  console.warn()  console.error()' },
+    {
+        pattern: /^import\s/,
+        hint: 'import {x} from "mikrojs/module"  — built-in modules: fs, sys, stdio',
+    },
+];
+export const WELCOME_HINT = 'Enter to submit  |  Ctrl+D to exit  |  Ctrl+C to clear  |  /help for commands';
+export const MULTILINE_HINT = 'Ctrl+Enter to submit  |  Enter to add line';
+function historyFile() {
+    return join(getMikroDir(), 'history.txt');
+}
+const HISTORY_MAX = 200;
+// ── Pure helpers ───────────────────────────────────────────
+/** Find the line index and column for a cursor position in text */
+export function cursorLocation(text, cursor) {
+    const lines = text.split('\n');
+    let pos = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lineLen = lines[i].length;
+        if (cursor <= pos + lineLen) {
+            return { line: i, col: cursor - pos, lineCount: lines.length };
+        }
+        pos += lineLen + 1;
+    }
+    return { line: lines.length - 1, col: 0, lineCount: lines.length };
+}
+/** Get the start offset of a given line index */
+export function lineStartOffset(text, lineIdx) {
+    let pos = 0;
+    const lines = text.split('\n');
+    for (let i = 0; i < lineIdx && i < lines.length; i++) {
+        pos += lines[i].length + 1;
+    }
+    return pos;
+}
+function resolveContextHint(input) {
+    // Slash command autocomplete: filter matching commands as you type
+    if (input.startsWith('/') && !input.includes(' ') && !input.includes('\n')) {
+        const matches = SLASH_COMMANDS.filter((cmd) => cmd.startsWith(input));
+        if (matches.length > 0)
+            return matches.join('  ');
+        return null;
+    }
+    return CONTEXT_HINTS.find((h) => h.pattern.test(input))?.hint ?? null;
+}
+// ── History persistence ────────────────────────────────────
+export function loadHistory() {
+    try {
+        return readFileSync(historyFile(), 'utf-8')
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => line.replace(/\\n/g, '\n').replace(/\\\\/g, '\\'))
+            .slice(-HISTORY_MAX);
+    }
+    catch {
+        return [];
+    }
+}
+export function appendHistory(entry) {
+    try {
+        const escaped = entry.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
+        appendFileSync(historyFile(), escaped + '\n');
+    }
+    catch {
+        // ignore write errors
+    }
+}
+// ── Initial state ──────────────────────────────────────────
+export function createInitialState(port, history = []) {
+    return {
+        connection: { type: 'connecting' },
+        port,
+        input: '',
+        cursor: 0,
+        history,
+        historyIdx: -1,
+        historyDraft: null,
+        showWelcome: true,
+        evaluating: false,
+        paused: false,
+        showTroubleshooting: false,
+        ctrlCPending: false,
+        returnPending: false,
+        disabled: false,
+        deployStatus: null,
+        footerError: null,
+        overrideHint: null,
+        contextHint: null,
+        pendingInput: null,
+        pendingTiming: null,
+        overlay: null,
+        events: [{ type: 'connecting', port }],
+    };
+}
+// ── Reducer ────────────────────────────────────────────────
+export function reduce(state, action) {
+    switch (action.type) {
+        case 'deviceEvent':
+            return reduceSessionEvent(state, action.event);
+        case 'key':
+            return reduceKey(state, action.ch, action.key);
+        case 'setDisabled':
+            return [
+                {
+                    ...state,
+                    disabled: action.disabled,
+                    deployStatus: action.disabled ? state.deployStatus : null,
+                    // A new cycle starts fresh — clear any sticky footer error
+                    // from the previous cycle.
+                    footerError: action.disabled ? null : state.footerError,
+                },
+                [],
+            ];
+        case 'setDeployStatus':
+            return [{ ...state, deployStatus: action.message }, []];
+        case 'setFooterError':
+            return [{ ...state, footerError: action.message }, []];
+        case 'setError': {
+            const connection = { type: 'error', message: action.message };
+            const errorEvent = { type: 'error', text: action.message };
+            return [
+                { ...state, connection, showTroubleshooting: true, events: [...state.events, errorEvent] },
+                [],
+            ];
+        }
+        case 'showTroubleshooting':
+            if (state.connection.type === 'ready')
+                return [state, []];
+            return [{ ...state, showTroubleshooting: true }, []];
+        case 'ctrlCTimeout':
+            if (!state.ctrlCPending)
+                return [state, []];
+            return [{ ...state, ctrlCPending: false, overrideHint: null }, []];
+        case 'returnResolve':
+            return reduceReturnResolve(state, action);
+        case 'closeOverlay':
+            return [{ ...state, overlay: null }, []];
+    }
+}
+// ── Session event handling ─────────────────────────────────
+function reduceSessionEvent(state, event) {
+    switch (event.type) {
+        case 'ready': {
+            if (state.connection.type === 'ready')
+                return [state, []];
+            const connection = {
+                type: 'ready',
+                chip: event.chip,
+                deviceId: event.id,
+                firmwareVersion: event.version,
+            };
+            return [
+                { ...state, connection, showTroubleshooting: false, events: [...state.events, event] },
+                [],
+            ];
+        }
+        case 'log':
+        case 'warn':
+        case 'error':
+        case 'info':
+        case 'debug':
+            return [{ ...state, events: [...state.events, event] }, []];
+        case 'eval_error':
+            return [{ ...state, evaluating: false, events: [...state.events, event] }, []];
+        case 'result': {
+            if (event.text.length > 0) {
+                return [{ ...state, evaluating: false, events: [...state.events, event] }, []];
+            }
+            return [{ ...state, evaluating: false }, []];
+        }
+        case 'completions': {
+            const result = event.result;
+            if (!result || result.items.length === 0)
+                return [state, []];
+            if (result.items.length === 1) {
+                const input = result.items[0];
+                return [{ ...state, input, cursor: input.length }, []];
+            }
+            return [{ ...state, events: [...state.events, event] }, []];
+        }
+        case 'prompt': {
+            // Flush pending input now that we have timing info from the prompt
+            const next = flushPendingInput({ ...state, pendingTiming: event.timing }, event);
+            return [next, []];
+        }
+        case 'raw':
+        case 'test':
+            return [{ ...state, events: [...state.events, event] }, []];
+        case 'disconnect': {
+            if (event.error) {
+                const connection = { type: 'error', message: event.error };
+                return [{ ...state, connection, events: [...state.events, event] }, []];
+            }
+            return [state, [{ type: 'end' }]];
+        }
+        default:
+            return [state, []];
+    }
+}
+function flushPendingInput(state, _trigger) {
+    if (!state.pendingInput)
+        return state;
+    const inputEvent = {
+        type: 'input',
+        code: state.pendingInput,
+        timing: state.pendingTiming ?? undefined,
+    };
+    return {
+        ...state,
+        pendingInput: null,
+        pendingTiming: null,
+        events: [...state.events, inputEvent],
+    };
+}
+// ── Key handling ───────────────────────────────────────────
+function reduceKey(state, ch, key) {
+    // Overlay active: input goes to the overlay component, not the REPL
+    if (state.overlay)
+        return [state, []];
+    // Before ready: only allow exit
+    if (state.connection.type !== 'ready') {
+        if (key.ctrl && (ch === 'q' || ch === 'd'))
+            return [state, [{ type: 'end' }]];
+        return [state, []];
+    }
+    // ── Control sequences ──────────────────────────────────
+    if (key.ctrl && ch === 'q')
+        return [state, [{ type: 'exit' }, { type: 'end' }]];
+    if (key.ctrl && ch === 'r') {
+        const connection = { type: 'connecting', message: 'Restarting…' };
+        const event = { type: 'restarting' };
+        return [{ ...state, connection, events: [...state.events, event] }, [{ type: 'restart' }]];
+    }
+    if (key.ctrl && ch === 'd' && state.input === '') {
+        return [state, [{ type: 'exit' }, { type: 'end' }]];
+    }
+    if (key.ctrl && ch === 'c') {
+        return reduceCtrlC(state);
+    }
+    if (state.disabled)
+        return [state, []];
+    if (key.tab) {
+        const input = state.input.slice(0, state.cursor) + '  ' + state.input.slice(state.cursor);
+        return [{ ...state, input, cursor: state.cursor + 2, showWelcome: false }, []];
+    }
+    // ── Newline (Shift+Enter or Alt+Enter) ─────────────────
+    if (key.return && (key.shift || key.meta)) {
+        const input = state.input.slice(0, state.cursor) + '\n' + state.input.slice(state.cursor);
+        return [{ ...state, input, cursor: state.cursor + 1, showWelcome: false }, []];
+    }
+    // ── Submit (Ctrl+Enter) ────────────────────────────────
+    if (key.return && key.ctrl) {
+        return reduceSubmit(state);
+    }
+    // ── Enter (deferred for paste detection) ───────────────
+    if (key.return && !key.ctrl) {
+        const multiline = state.input.includes('\n');
+        return [{ ...state, returnPending: true }, [{ type: 'scheduleReturnResolve', multiline }]];
+    }
+    // ── Home / Ctrl+A ──────────────────────────────────────
+    if (key.home || (key.ctrl && ch === 'a')) {
+        const lineStart = state.input.lastIndexOf('\n', state.cursor - 1) + 1;
+        return [{ ...state, cursor: lineStart }, []];
+    }
+    // ── End / Ctrl+E ───────────────────────────────────────
+    if (key.end || (key.ctrl && ch === 'e')) {
+        let lineEnd = state.input.indexOf('\n', state.cursor);
+        if (lineEnd === -1)
+            lineEnd = state.input.length;
+        return [{ ...state, cursor: lineEnd }, []];
+    }
+    // ── Alt+Left / ESC b ──────────────────────────────────
+    if ((key.leftArrow && key.meta) || (key.meta && ch === 'b')) {
+        let i = state.cursor - 1;
+        while (i > 0 && /\W/.test(state.input[i - 1]))
+            i--;
+        while (i > 0 && /\w/.test(state.input[i - 1]))
+            i--;
+        return [{ ...state, cursor: Math.max(0, i) }, []];
+    }
+    // ── Alt+Right / ESC f ─────────────────────────────────
+    if ((key.rightArrow && key.meta) || (key.meta && ch === 'f')) {
+        let i = state.cursor;
+        while (i < state.input.length && /\W/.test(state.input[i]))
+            i++;
+        while (i < state.input.length && /\w/.test(state.input[i]))
+            i++;
+        return [{ ...state, cursor: i }, []];
+    }
+    // ── Arrow keys ─────────────────────────────────────────
+    if (key.leftArrow)
+        return [{ ...state, cursor: Math.max(0, state.cursor - 1) }, []];
+    if (key.rightArrow)
+        return [{ ...state, cursor: Math.min(state.input.length, state.cursor + 1) }, []];
+    if (key.upArrow)
+        return [reduceUpArrow(state), []];
+    if (key.downArrow)
+        return [reduceDownArrow(state), []];
+    // ── Ctrl+S — trigger deploy (Ctrl+Shift+S forces full redeploy) ─
+    if (key.ctrl && ch === 's') {
+        return [state, [{ type: 'deploy', force: key.shift }]];
+    }
+    // ── Alt+Backspace — delete previous word ───────────────
+    if (key.backspace && key.meta) {
+        let i = state.cursor - 1;
+        while (i > 0 && /\W/.test(state.input[i - 1]))
+            i--;
+        while (i > 0 && /\w/.test(state.input[i - 1]))
+            i--;
+        const wordStart = Math.max(0, i);
+        if (wordStart < state.cursor) {
+            const input = state.input.slice(0, wordStart) + state.input.slice(state.cursor);
+            return [
+                {
+                    ...state,
+                    input,
+                    cursor: wordStart,
+                    overrideHint: null,
+                    contextHint: resolveContextHint(input),
+                },
+                [],
+            ];
+        }
+        return [state, []];
+    }
+    // ── Backspace ───────────────────────────────────────────
+    if (key.backspace) {
+        if (state.cursor > 0) {
+            const input = state.input.slice(0, state.cursor - 1) + state.input.slice(state.cursor);
+            return [
+                {
+                    ...state,
+                    input,
+                    cursor: state.cursor - 1,
+                    overrideHint: null,
+                    contextHint: resolveContextHint(input),
+                },
+                [],
+            ];
+        }
+        return [state, []];
+    }
+    // ── Delete (forward) ───────────────────────────────────
+    if (key.delete) {
+        if (state.cursor < state.input.length) {
+            const input = state.input.slice(0, state.cursor) + state.input.slice(state.cursor + 1);
+            return [
+                {
+                    ...state,
+                    input,
+                    overrideHint: null,
+                    contextHint: resolveContextHint(input),
+                },
+                [],
+            ];
+        }
+        return [state, []];
+    }
+    // ── Regular character input ────────────────────────────
+    if (ch && !key.ctrl && !key.meta) {
+        return reduceCharInput(state, ch);
+    }
+    return [state, []];
+}
+function reduceCtrlC(state) {
+    if (state.input.length > 0) {
+        return [
+            { ...state, input: '', cursor: 0, ctrlCPending: false, overrideHint: null, contextHint: null },
+            [],
+        ];
+    }
+    if (state.ctrlCPending) {
+        return [state, [{ type: 'exit' }, { type: 'end' }]];
+    }
+    return [
+        { ...state, ctrlCPending: true, overrideHint: 'Press Ctrl+C again to exit, or Ctrl+D' },
+        [{ type: 'scheduleCtrlCTimeout' }],
+    ];
+}
+function reduceCharInput(state, ch) {
+    let { input, cursor } = state;
+    // If Return is pending, it was a paste newline — insert \n instead of submitting
+    if (state.returnPending) {
+        input = input.slice(0, cursor) + '\n' + input.slice(cursor);
+        cursor++;
+    }
+    // Normalize line endings and expand tabs
+    const text = ch.replace(/\r\n?/g, '\n').replace(/\t/g, '  ');
+    input = input.slice(0, cursor) + text + input.slice(cursor);
+    cursor += text.length;
+    return [
+        {
+            ...state,
+            input,
+            cursor,
+            returnPending: false,
+            historyIdx: -1,
+            ctrlCPending: false,
+            showWelcome: false,
+            overrideHint: null,
+            contextHint: resolveContextHint(input),
+        },
+        [],
+    ];
+}
+function reduceUpArrow(state) {
+    const loc = cursorLocation(state.input, state.cursor);
+    if (loc.line > 0) {
+        const targetStart = lineStartOffset(state.input, loc.line - 1);
+        const targetLineLen = (state.input.split('\n')[loc.line - 1] ?? '').length;
+        return { ...state, cursor: targetStart + Math.min(loc.col, targetLineLen) };
+    }
+    if (state.cursor === 0 && state.history.length > 0) {
+        const historyDraft = state.historyIdx < 0 ? state.input : state.historyDraft;
+        const idx = state.historyIdx < 0 ? state.history.length - 1 : Math.max(0, state.historyIdx - 1);
+        return { ...state, historyIdx: idx, historyDraft, input: state.history[idx], cursor: 0 };
+    }
+    if (loc.line === 0 && state.cursor > 0) {
+        return { ...state, cursor: 0 };
+    }
+    return state;
+}
+function reduceDownArrow(state) {
+    const loc = cursorLocation(state.input, state.cursor);
+    if (loc.line < loc.lineCount - 1) {
+        const targetStart = lineStartOffset(state.input, loc.line + 1);
+        const targetLineLen = (state.input.split('\n')[loc.line + 1] ?? '').length;
+        return { ...state, cursor: targetStart + Math.min(loc.col, targetLineLen) };
+    }
+    if (loc.line === loc.lineCount - 1 && state.cursor < state.input.length) {
+        return { ...state, cursor: state.input.length };
+    }
+    if (state.cursor === state.input.length && state.historyIdx >= 0) {
+        const idx = state.historyIdx + 1;
+        if (idx >= state.history.length) {
+            return {
+                ...state,
+                historyIdx: -1,
+                input: state.historyDraft ?? '',
+                historyDraft: null,
+                cursor: (state.historyDraft ?? '').length,
+            };
+        }
+        return {
+            ...state,
+            historyIdx: idx,
+            input: state.history[idx],
+            cursor: state.history[idx].length,
+        };
+    }
+    return state;
+}
+// ── Submit ─────────────────────────────────────────────────
+function reduceSubmit(state) {
+    if (state.disabled)
+        return [state, []];
+    const value = state.input;
+    // Auto-continue if expression is incomplete
+    if (isIncomplete(value)) {
+        const input = `${value}\n`;
+        return [{ ...state, input, cursor: input.length }, []];
+    }
+    const code = value.trim();
+    if (!code)
+        return [state, []];
+    const effects = [{ type: 'appendHistory', entry: code }];
+    const resetState = {
+        ...state,
+        history: [...state.history, code].slice(-HISTORY_MAX),
+        historyIdx: -1,
+        input: '',
+        cursor: 0,
+    };
+    if (code === '/env') {
+        return [{ ...resetState, overlay: 'env' }, effects];
+    }
+    if (code === '/exit') {
+        return [resetState, [...effects, { type: 'exit' }, { type: 'end' }]];
+    }
+    if (!code.includes('\n') && /^\/[a-z]+(\s|$)/i.test(code)) {
+        const inputEvent = { type: 'input', code };
+        const next = { ...resetState, events: [...resetState.events, inputEvent] };
+        if (code === '/pause')
+            return [{ ...next, paused: true }, [...effects, { type: 'directive', code }]];
+        if (code === '/resume')
+            return [{ ...next, paused: false }, [...effects, { type: 'directive', code }]];
+        return [next, [...effects, { type: 'directive', code }]];
+    }
+    // Eval: defer input echo until result arrives
+    return [
+        {
+            ...resetState,
+            pendingInput: code,
+            pendingTiming: null,
+            evaluating: true,
+        },
+        [...effects, { type: 'eval', code }],
+    ];
+}
+// ── Return resolve (paste detection) ───────────────────────
+function reduceReturnResolve(state, _action) {
+    if (!state.returnPending)
+        return [state, []];
+    const next = { ...state, returnPending: false };
+    // Single-line: submit
+    if (!state.input.includes('\n')) {
+        return reduceSubmit(next);
+    }
+    // Multi-line: insert newline
+    const input = state.input.slice(0, state.cursor) + '\n' + state.input.slice(state.cursor);
+    return [{ ...next, input, cursor: state.cursor + 1 }, []];
+}
+const CONNECTION_TIMEOUT_MS = 15_000;
+export function createRepl(options) {
+    const { session, port, onEnd, deployEnabled = true } = options;
+    const timeoutMs = options.timeout ?? CONNECTION_TIMEOUT_MS;
+    const loadHistoryFn = options.loadHistory ?? loadHistory;
+    const saveHistoryFn = options.saveHistory ?? appendHistory;
+    const actions$ = new Subject();
+    const deploys$ = new Subject();
+    const restarts$ = new Subject();
+    const initial = createInitialState(port, loadHistoryFn());
+    const sessionActions$ = session.messages$.pipe(map((event) => ({ type: 'deviceEvent', event })));
+    // Connection timers: restart device after 2s (in case MSG_READY was sent
+    // before the CLI connected), show troubleshooting after 5s, hard error
+    // after full timeout.
+    const ready$ = sessionActions$.pipe(filter((a) => a.type === 'deviceEvent' && a.event.type === 'ready'), first());
+    const troubleshootingTimer$ = timer(5_000).pipe(takeUntil(ready$), map(() => ({ type: 'showTroubleshooting' })));
+    const connectionTimeout$ = timer(timeoutMs).pipe(takeUntil(ready$), map(() => ({
+        type: 'setError',
+        message: `Connection timed out after ${timeoutMs / 1000}s`,
+    })));
+    // The device only sends MSG_READY in reply to CMD_HELLO. awaitReady$
+    // polls HELLO until a fresh ready arrives; we merge it as a side-effect
+    // (no actions emitted) so the existing 'ready' deviceEvent flow drives
+    // the state machine. catchError swallows the timeout because
+    // connectionTimeout$ above already surfaces it as a 'setError' action.
+    const handshakeDriver$ = session.awaitReady$(timeoutMs).pipe(catchError(() => EMPTY), ignoreElements());
+    // After a user-triggered restart (Ctrl+R) the device reboots and stops
+    // emitting MSG_READY until something polls CMD_HELLO again. Re-subscribe
+    // to awaitReady$ on each restart so the handshake resumes; without this
+    // the connection state stays in 'Restarting…' forever.
+    const restartHandshakeDriver$ = restarts$.pipe(switchMap(() => session.awaitReady$(timeoutMs).pipe(catchError(() => EMPTY))), ignoreElements());
+    const state$ = merge(sessionActions$, actions$, troubleshootingTimer$, connectionTimeout$, handshakeDriver$, restartHandshakeDriver$).pipe(scan((state, action) => {
+        const [nextState, effects] = reduce(state, action);
+        for (const effect of effects) {
+            handleEffect(effect);
+        }
+        return nextState;
+    }, initial), startWith(initial), shareReplay({ bufferSize: 1, refCount: true }));
+    function handleEffect(effect) {
+        switch (effect.type) {
+            case 'eval':
+                session.eval(effect.code);
+                break;
+            case 'directive':
+                session.directive(effect.code);
+                break;
+            case 'exit':
+                session.exit();
+                break;
+            case 'restart':
+                session.restart();
+                restarts$.next();
+                break;
+            case 'end':
+                onEnd();
+                break;
+            case 'deploy':
+                // When `deployEnabled` is false (e.g. `mikro console`), the Ctrl+S
+                // keybind is a no-op so it doesn't feed a Subject that nothing
+                // subscribes to.
+                if (deployEnabled)
+                    deploys$.next({ force: effect.force });
+                break;
+            case 'appendHistory':
+                saveHistoryFn(effect.entry);
+                break;
+            case 'scheduleCtrlCTimeout':
+                setTimeout(() => actions$.next({ type: 'ctrlCTimeout' }), 3000);
+                break;
+            case 'scheduleReturnResolve':
+                queueMicrotask(() => actions$.next({ type: 'returnResolve' }));
+                break;
+        }
+    }
+    return {
+        state$,
+        deploys$: deploys$.asObservable(),
+        keyInput(ch, key) {
+            actions$.next({ type: 'key', ch, key });
+        },
+        setDisabled(disabled) {
+            actions$.next({ type: 'setDisabled', disabled });
+        },
+        setDeployStatus(message) {
+            actions$.next({ type: 'setDeployStatus', message });
+        },
+        setError(message) {
+            actions$.next({ type: 'setError', message });
+        },
+        setFooterError(message) {
+            actions$.next({ type: 'setFooterError', message });
+        },
+        logEvent(event) {
+            // For non-ReplEvent log entries (e.g. `{type: 'restarting'}`) we
+            // could add a dedicated action, but every caller today emits a
+            // ReplEvent, so routing through deviceEvent keeps the surface
+            // minimal. The reducer treats it the same as a real device event.
+            if (isReplEvent(event)) {
+                actions$.next({ type: 'deviceEvent', event });
+            }
+        },
+        closeOverlay() {
+            actions$.next({ type: 'closeOverlay' });
+        },
+    };
+}
+function isReplEvent(event) {
+    switch (event.type) {
+        case 'connecting':
+        case 'restarting':
+        case 'input':
+            return false;
+        default:
+            return true;
+    }
+}
+//# sourceMappingURL=replStateMachine.js.map