@positronic/cli 0.0.55 → 0.0.57

package/dist/src/components/brain-run.js

@@ -48,6 +48,13 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -117,6 +124,10 @@ function _object_spread_props(target, source) {
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -216,280 +227,302 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import React, { useState, useEffect, useCallback } from 'react';
+import React, { useMemo, useEffect } from 'react';
 import { Box, Text, useApp } from 'ink';
+import { createMachine, state, transition, reduce, invoke, immediate, guard } from 'robot3';
+import { useMachine } from 'react-robot';
 import { ErrorComponent } from './error.js';
 import { SelectList } from './select-list.js';
 import { Watch } from './watch.js';
 import { apiClient, isApiLocalDevMode } from '../commands/helpers.js';
-export var BrainRun = function(param) {
-    var identifier = param.identifier, watch = param.watch, options = param.options;
-    var _useState = _sliced_to_array(useState('searching'), 2), phase = _useState[0], setPhase = _useState[1];
-    var _useState1 = _sliced_to_array(useState([]), 2), brains = _useState1[0], setBrains = _useState1[1];
-    var _useState2 = _sliced_to_array(useState(null), 2), runId = _useState2[0], setRunId = _useState2[1];
-    var _useState3 = _sliced_to_array(useState(null), 2), error = _useState3[0], setError = _useState3[1];
-    var exit = useApp().exit;
-    var getConnectionError = useCallback(function() {
-        if (isApiLocalDevMode()) {
-            return {
-                title: 'Connection Error',
-                message: 'Error connecting to the local development server.',
-                details: "Please ensure the server is running ('positronic server' or 'px s')."
-            };
-        } else {
-            return {
-                title: 'Connection Error',
-                message: 'Error connecting to the remote project server.',
-                details: 'Please check your network connection and verify the project URL is correct.'
-            };
-        }
-    }, []);
-    var runBrain = useCallback(function(brainTitle) {
-        return _async_to_generator(function() {
-            var response, result, errorText, err, baseError;
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        setPhase('running');
-                        _state.label = 1;
-                    case 1:
-                        _state.trys.push([
-                            1,
-                            8,
-                            ,
-                            9
-                        ]);
-                        return [
-                            4,
-                            apiClient.fetch('/brains/runs', {
-                                method: 'POST',
-                                headers: {
-                                    'Content-Type': 'application/json'
-                                },
-                                body: JSON.stringify({
-                                    identifier: brainTitle,
-                                    options: options
-                                })
+// Helper to get connection error message
+var getConnectionError = function() {
+    if (isApiLocalDevMode()) {
+        return {
+            title: 'Connection Error',
+            message: 'Error connecting to the local development server.',
+            details: "Please ensure the server is running ('positronic server' or 'px s')."
+        };
+    }
+    return {
+        title: 'Connection Error',
+        message: 'Error connecting to the remote project server.',
+        details: 'Please check your network connection and verify the project URL is correct.'
+    };
+};
+// Error handler for network errors
+var handleNetworkError = function(err) {
+    // If it's already an ErrorInfo object (thrown from our async functions)
+    if (err && (typeof err === "undefined" ? "undefined" : _type_of(err)) === 'object' && 'title' in err && 'message' in err) {
+        return err;
+    }
+    // Network/connection error
+    var baseError = getConnectionError();
+    var message = _instanceof(err, Error) ? err.message : String(err);
+    return _object_spread_props(_object_spread({}, baseError), {
+        details: "".concat(baseError.details, " ").concat(message)
+    });
+};
+// Async functions for invoke states
+var searchBrains = function(ctx) {
+    return _async_to_generator(function() {
+        var url, response, errorText;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    url = "/brains?q=".concat(encodeURIComponent(ctx.identifier));
+                    return [
+                        4,
+                        apiClient.fetch(url, {
+                            method: 'GET'
+                        })
+                    ];
+                case 1:
+                    response = _state.sent();
+                    if (!!response.ok) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        response.text()
+                    ];
+                case 2:
+                    errorText = _state.sent();
+                    throw {
+                        title: 'Server Error',
+                        message: "Error searching for brains: ".concat(response.status, " ").concat(response.statusText),
+                        details: errorText
+                    };
+                case 3:
+                    return [
+                        4,
+                        response.json()
+                    ];
+                case 4:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+            }
+        });
+    })();
+};
+var startRun = function(ctx) {
+    return _async_to_generator(function() {
+        var response, errorText;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        apiClient.fetch('/brains/runs', {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                identifier: ctx.selectedBrainTitle,
+                                options: ctx.options
                             })
-                        ];
-                    case 2:
-                        response = _state.sent();
-                        if (!(response.status === 201)) return [
-                            3,
-                            4
-                        ];
-                        return [
-                            4,
-                            response.json()
-                        ];
-                    case 3:
-                        result = _state.sent();
-                        setRunId(result.brainRunId);
-                        setPhase('complete');
-                        return [
-                            3,
-                            7
-                        ];
-                    case 4:
-                        if (!(response.status === 404)) return [
-                            3,
-                            5
-                        ];
-                        setError({
+                        })
+                    ];
+                case 1:
+                    response = _state.sent();
+                    if (!(response.status === 201)) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        response.json()
+                    ];
+                case 2:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 3:
+                    if (response.status === 404) {
+                        throw {
                             title: 'Brain Not Found',
-                            message: "Brain '".concat(brainTitle, "' not found."),
+                            message: "Brain '".concat(ctx.selectedBrainTitle, "' not found."),
                             details: 'The brain may have been removed or renamed since the search.'
-                        });
-                        setPhase('error');
-                        return [
-                            3,
-                            7
-                        ];
-                    case 5:
-                        return [
-                            4,
-                            response.text()
-                        ];
-                    case 6:
-                        errorText = _state.sent();
-                        setError({
-                            title: 'Server Error',
-                            message: "Error starting brain run: ".concat(response.status, " ").concat(response.statusText),
-                            details: errorText
-                        });
-                        setPhase('error');
-                        _state.label = 7;
-                    case 7:
-                        return [
-                            3,
-                            9
-                        ];
-                    case 8:
-                        err = _state.sent();
-                        baseError = getConnectionError();
-                        setError(_object_spread_props(_object_spread({}, baseError), {
-                            details: "".concat(baseError.details, " ").concat(err.message)
-                        }));
-                        setPhase('error');
-                        return [
-                            3,
-                            9
-                        ];
-                    case 9:
-                        return [
-                            2
-                        ];
-                }
-            });
-        })();
-    }, [
-        options,
-        getConnectionError
-    ]);
-    // Initial search
-    useEffect(function() {
-        var searchBrains = function() {
-            return _async_to_generator(function() {
-                var url, response, errorText, data, err, baseError;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            _state.trys.push([
-                                0,
-                                9,
-                                ,
-                                10
-                            ]);
-                            url = "/brains?q=".concat(encodeURIComponent(identifier));
-                            return [
-                                4,
-                                apiClient.fetch(url, {
-                                    method: 'GET'
-                                })
-                            ];
-                        case 1:
-                            response = _state.sent();
-                            if (!!response.ok) return [
-                                3,
-                                3
-                            ];
-                            return [
-                                4,
-                                response.text()
-                            ];
-                        case 2:
-                            errorText = _state.sent();
-                            setError({
-                                title: 'Server Error',
-                                message: "Error searching for brains: ".concat(response.status, " ").concat(response.statusText),
-                                details: errorText
-                            });
-                            setPhase('error');
-                            return [
-                                2
-                            ];
-                        case 3:
-                            return [
-                                4,
-                                response.json()
-                            ];
-                        case 4:
-                            data = _state.sent();
-                            if (!(data.count === 0)) return [
-                                3,
-                                5
-                            ];
-                            setError({
-                                title: 'Brain Not Found',
-                                message: "No brains found matching '".concat(identifier, "'."),
-                                details: 'Please check that:\n  1. The brain name is spelled correctly\n  2. The brain exists in your project\n  3. The brain has been properly defined and exported\n\nYou can list available brains with: positronic list'
-                            });
-                            setPhase('error');
-                            return [
-                                3,
-                                8
-                            ];
-                        case 5:
-                            if (!(data.count === 1)) return [
-                                3,
-                                7
-                            ];
-                            // Exactly one match - run it directly
-                            return [
-                                4,
-                                runBrain(data.brains[0].title)
-                            ];
-                        case 6:
-                            _state.sent();
-                            return [
-                                3,
-                                8
-                            ];
-                        case 7:
-                            // Multiple matches - show disambiguation UI
-                            setBrains(data.brains);
-                            setPhase('disambiguating');
-                            _state.label = 8;
-                        case 8:
-                            return [
-                                3,
-                                10
-                            ];
-                        case 9:
-                            err = _state.sent();
-                            baseError = getConnectionError();
-                            setError(_object_spread_props(_object_spread({}, baseError), {
-                                details: "".concat(baseError.details, " ").concat(err.message)
-                            }));
-                            setPhase('error');
-                            return [
-                                3,
-                                10
-                            ];
-                        case 10:
-                            return [
-                                2
-                            ];
+                        };
                     }
-                });
-            })();
+                    return [
+                        4,
+                        response.text()
+                    ];
+                case 4:
+                    errorText = _state.sent();
+                    throw {
+                        title: 'Server Error',
+                        message: "Error starting brain run: ".concat(response.status, " ").concat(response.statusText),
+                        details: errorText
+                    };
+            }
+        });
+    })();
+};
+// Reducers
+var storeBrainSearchResult = reduce(function(ctx, ev) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        brainSearchResult: ev.data
+    });
+});
+var applySingleBrainFound = reduce(function(ctx) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        selectedBrainTitle: ctx.brainSearchResult.brains[0].title
+    });
+});
+var applyBrainsMultiple = reduce(function(ctx) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        brains: ctx.brainSearchResult.brains
+    });
+});
+var applyBrainNotFoundError = reduce(function(ctx) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        error: {
+            title: 'Brain Not Found',
+            message: "No brains found matching '".concat(ctx.identifier, "'."),
+            details: 'Please check that:\n  1. The brain name is spelled correctly\n  2. The brain exists in your project\n  3. The brain has been properly defined and exported\n\nYou can list available brains with: positronic list'
+        }
+    });
+});
+var setBrainTitleFromSelection = reduce(function(ctx, ev) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        selectedBrainTitle: ev.brainTitle
+    });
+});
+var storeRunResult = reduce(function(ctx, ev) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        runId: ev.data.brainRunId
+    });
+});
+var setErrorFromEvent = reduce(function(ctx, ev) {
+    return _object_spread_props(_object_spread({}, ctx), {
+        error: handleNetworkError(ev.error)
+    });
+});
+// Guards for routing
+var brainFoundGuard = guard(function(ctx) {
+    var _ctx_brainSearchResult;
+    return ((_ctx_brainSearchResult = ctx.brainSearchResult) === null || _ctx_brainSearchResult === void 0 ? void 0 : _ctx_brainSearchResult.count) === 1;
+});
+var brainNotFoundGuard = guard(function(ctx) {
+    var _ctx_brainSearchResult;
+    return ((_ctx_brainSearchResult = ctx.brainSearchResult) === null || _ctx_brainSearchResult === void 0 ? void 0 : _ctx_brainSearchResult.count) === 0;
+});
+var brainsMultipleGuard = guard(function(ctx) {
+    var _ctx_brainSearchResult;
+    var _ctx_brainSearchResult_count;
+    return ((_ctx_brainSearchResult_count = (_ctx_brainSearchResult = ctx.brainSearchResult) === null || _ctx_brainSearchResult === void 0 ? void 0 : _ctx_brainSearchResult.count) !== null && _ctx_brainSearchResult_count !== void 0 ? _ctx_brainSearchResult_count : 0) > 1;
+});
+// State machine definition
+var createBrainRunMachine = function(identifier, watch, options) {
+    return createMachine('searching', {
+        // Invoke state: search for brain by name
+        searching: invoke(searchBrains, transition('done', 'routeSearch', storeBrainSearchResult), transition('error', 'error', setErrorFromEvent)),
+        // Route based on brain search result
+        routeSearch: state(immediate('running', brainFoundGuard, applySingleBrainFound), immediate('error', brainNotFoundGuard, applyBrainNotFoundError), immediate('disambiguating', brainsMultipleGuard, applyBrainsMultiple)),
+        // User selects from multiple matching brains
+        disambiguating: state(transition('BRAIN_SELECTED', 'running', setBrainTitleFromSelection)),
+        // Invoke state: start the brain run
+        running: invoke(startRun, transition('done', 'complete', storeRunResult), transition('error', 'error', setErrorFromEvent)),
+        // Terminal states
+        complete: state(),
+        error: state()
+    }, function() {
+        return {
+            identifier: identifier,
+            watch: watch,
+            options: options,
+            brainSearchResult: null,
+            brains: [],
+            selectedBrainTitle: null,
+            runId: null,
+            error: null
         };
-        searchBrains();
+    });
+};
+/**
+ * BrainRun - Searches for a brain by identifier and runs it.
+ *
+ * State machine handles all async operations via invoke.
+ * Flow:
+ * 1. Search for brain by name (fuzzy search)
+ * 2. If single match, run it; if multiple, show disambiguation UI; if none, show error
+ * 3. Start the brain run
+ * 4. Show run ID or Watch component based on watch flag
+ */ export var BrainRun = function(param) {
+    var identifier = param.identifier, _param_watch = param.watch, watch = _param_watch === void 0 ? false : _param_watch, options = param.options;
+    var machine = useMemo(function() {
+        return createBrainRunMachine(identifier, watch, options);
     }, [
         identifier,
-        runBrain,
-        getConnectionError
+        watch,
+        options
     ]);
+    var _useMachine = _sliced_to_array(useMachine(machine), 2), current = _useMachine[0], send = _useMachine[1];
+    var exit = useApp().exit;
+    var currentState = current.name;
+    var _current_context = current.context, brains = _current_context.brains, runId = _current_context.runId, error = _current_context.error;
     // Exit the app when run completes without watch mode
     useEffect(function() {
-        if (phase === 'complete' && runId && !watch) {
+        if (currentState === 'complete' && runId && !watch) {
             exit();
         }
     }, [
-        phase,
+        currentState,
         runId,
         watch,
         exit
     ]);
-    // Maintain consistent Box wrapper to help Ink properly calculate
-    // terminal clearing between renders (prevents appending instead of overwriting)
-    return /*#__PURE__*/ React.createElement(Box, {
-        flexDirection: "column"
-    }, phase === 'searching' ? /*#__PURE__*/ React.createElement(Text, null, "Searching for brain '", identifier, "'...") : phase === 'error' && error ? /*#__PURE__*/ React.createElement(ErrorComponent, {
-        error: error
-    }) : phase === 'disambiguating' ? /*#__PURE__*/ React.createElement(SelectList, {
-        items: brains.map(function(b) {
-            return {
-                id: b.title,
-                label: b.title,
-                description: b.description
-            };
-        }),
-        header: "Multiple brains match '".concat(identifier, "':"),
-        onSelect: function(item) {
-            runBrain(item.label);
-        }
-    }) : phase === 'running' ? /*#__PURE__*/ React.createElement(Text, null, "Starting brain run...") : phase === 'complete' && runId ? watch ? /*#__PURE__*/ React.createElement(Watch, {
-        runId: runId
-    }) : /*#__PURE__*/ React.createElement(Text, null, "Run ID: ", runId) : null);
+    // Render based on state
+    switch(currentState){
+        case 'searching':
+        case 'routeSearch':
+            return /*#__PURE__*/ React.createElement(Box, {
+                flexDirection: "column"
+            }, /*#__PURE__*/ React.createElement(Text, null, "Searching for brain '", identifier, "'..."));
+        case 'disambiguating':
+            return /*#__PURE__*/ React.createElement(Box, {
+                flexDirection: "column"
+            }, /*#__PURE__*/ React.createElement(SelectList, {
+                items: brains.map(function(b) {
+                    return {
+                        id: b.title,
+                        label: b.title,
+                        description: b.description
+                    };
+                }),
+                header: "Multiple brains match '".concat(identifier, "':"),
+                onSelect: function(item) {
+                    send({
+                        type: 'BRAIN_SELECTED',
+                        brainTitle: item.label
+                    });
+                }
+            }));
+        case 'running':
+            return /*#__PURE__*/ React.createElement(Box, {
+                flexDirection: "column"
+            }, /*#__PURE__*/ React.createElement(Text, null, "Starting brain run..."));
+        case 'complete':
+            if (!runId) return null;
+            return /*#__PURE__*/ React.createElement(Box, {
+                flexDirection: "column"
+            }, watch ? /*#__PURE__*/ React.createElement(Watch, {
+                runId: runId
+            }) : /*#__PURE__*/ React.createElement(Text, null, "Run ID: ", runId));
+        case 'error':
+            return /*#__PURE__*/ React.createElement(Box, {
+                flexDirection: "column"
+            }, error ? /*#__PURE__*/ React.createElement(ErrorComponent, {
+                error: error
+            }) : null);
+        default:
+            return null;
+    }
 };

package/dist/src/components/brain-top-table.js

@@ -45,6 +45,10 @@ var getStatusColor = function(status) {
             return 'yellow';
         case STATUS.CANCELLED:
             return 'gray';
+        case STATUS.PAUSED:
+            return 'cyan';
+        case STATUS.WAITING:
+            return 'magenta';
         default:
             return 'white';
     }