@positronic/cli 0.0.46 → 0.0.48

package/dist/src/components/watch.js

@@ -6,6 +6,9 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -19,6 +22,9 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -46,6 +52,9 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -88,6 +97,9 @@ 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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -99,8 +111,7 @@ function _unsupported_iterable_to_array(o, minLen) {
 import React, { useState, useEffect, useRef } from 'react';
 import { Text, Box, useStdout } from 'ink';
 import { EventSource } from 'eventsource';
-import { BRAIN_EVENTS } from '@positronic/core';
-import { STATUS } from '@positronic/core';
+import { BRAIN_EVENTS, STATUS, createBrainExecutionMachine, sendEvent } from '@positronic/core';
 import { getApiBaseUrl, isApiLocalDevMode } from '../commands/helpers.js';
 import { ErrorComponent } from './error.js';
 // Get the index of the currently running step (or last completed if none running)
@@ -191,16 +202,18 @@ var StepWindow = function(param) {
     }, getStatusChar(nextStep.status), " ", nextStep.title)));
 };
 var BrainSection = function(param) {
-    var brain = param.brain, _param_isInner = param.isInner, isInner = _param_isInner === void 0 ? false : _param_isInner, brains = param.brains;
+    var brain = param.brain, _param_isInner = param.isInner, isInner = _param_isInner === void 0 ? false : _param_isInner, brainStack = param.brainStack;
     var indent = isInner ? 2 : 0;
     var completed = getCompletedCount(brain.steps);
     var total = brain.steps.length;
     // Find the currently running step to check for inner brain
     var currentIndex = getCurrentStepIndex(brain.steps);
     var currentStep = brain.steps[currentIndex];
-    // Find any inner brain associated with the current step
-    var innerBrain = currentStep ? Array.from(brains.values()).find(function(b) {
-        return b.parentStepId === currentStep.id && !b.isComplete;
+    // Find any inner brain associated with the current step (active inner brains are on the stack)
+    // Must exclude the current brain to prevent infinite recursion when a restarted brain
+    // has parentStepId matching its own step IDs
+    var innerBrain = currentStep ? brainStack.find(function(b) {
+        return b.parentStepId === currentStep.id && b !== brain;
     }) : null;
     return /*#__PURE__*/ React.createElement(Box, {
         flexDirection: "column",
@@ -226,22 +239,20 @@ var BrainSection = function(param) {
     }, /*#__PURE__*/ React.createElement(BrainSection, {
         brain: innerBrain,
         isInner: true,
-        brains: brains
+        brainStack: brainStack
     })));
 };
 export var Watch = function(param) {
     var runId = param.runId;
     var write = useStdout().write;
-    // Track all brains (parent and inner) by their brainRunId
-    var _useState = _sliced_to_array(useState(new Map()), 2), brains = _useState[0], setBrains = _useState[1];
+    // Use state machine to track brain execution state
+    var machineRef = useRef(createBrainExecutionMachine());
+    // Store brain stack in state to trigger re-renders when it changes
+    var _useState = _sliced_to_array(useState([]), 2), brainStack = _useState[0], setBrainStack = _useState[1];
     var _useState1 = _sliced_to_array(useState(undefined), 2), brainError = _useState1[0], setBrainError = _useState1[1];
     var _useState2 = _sliced_to_array(useState(null), 2), error = _useState2[0], setError = _useState2[1];
     var _useState3 = _sliced_to_array(useState(false), 2), isConnected = _useState3[0], setIsConnected = _useState3[1];
     var _useState4 = _sliced_to_array(useState(false), 2), isCompleted = _useState4[0], setIsCompleted = _useState4[1];
-    // Track the main brain's brainRunId to distinguish from inner brain events
-    var mainBrainRunIdRef = useRef(null);
-    // Track the currently running step ID to associate inner brains with their parent step
-    var runningStepIdRef = useRef(null);
     // Enter alternate screen buffer on mount, exit on unmount
     // Skip in test environment to avoid interfering with test output capture
     useEffect(function() {
@@ -261,11 +272,13 @@ export var Watch = function(param) {
         var baseUrl = getApiBaseUrl();
         var url = "".concat(baseUrl, "/brains/runs/").concat(runId, "/watch");
         var es = new EventSource(url);
+        // Reset state machine for new connection
+        machineRef.current = createBrainExecutionMachine();
         setIsConnected(false);
         setError(null);
-        setBrains(new Map());
-        mainBrainRunIdRef.current = null;
-        runningStepIdRef.current = null;
+        setBrainStack([]);
+        setBrainError(undefined);
+        setIsCompleted(false);
         es.onopen = function() {
             setIsConnected(true);
             setError(null);
@@ -273,68 +286,29 @@ export var Watch = function(param) {
         es.onmessage = function(event) {
             try {
                 var eventData = JSON.parse(event.data);
-                // Handle brain start - register new brain (parent or inner)
-                if (eventData.type === BRAIN_EVENTS.START || eventData.type === BRAIN_EVENTS.RESTART) {
-                    var startEvent = eventData;
-                    var isMainBrain = mainBrainRunIdRef.current === null;
-                    if (isMainBrain) {
-                        mainBrainRunIdRef.current = startEvent.brainRunId;
-                    }
-                    setBrains(function(prev) {
-                        var next = new Map(prev);
-                        next.set(startEvent.brainRunId, {
-                            brainRunId: startEvent.brainRunId,
-                            brainTitle: startEvent.brainTitle,
-                            steps: [],
-                            parentStepId: isMainBrain ? null : runningStepIdRef.current,
-                            isComplete: false
+                var machine = machineRef.current;
+                // Feed event to state machine - it handles all the state tracking
+                sendEvent(machine, eventData);
+                // Update React state from machine context to trigger re-render
+                // Deep copy brainStack to ensure React detects the change
+                // Note: Only update if brainStack has entries - preserve last known state for completed brains
+                var currentStack = machine.context.brainStack;
+                if (currentStack.length > 0) {
+                    setBrainStack(currentStack.map(function(entry) {
+                        return _object_spread_props(_object_spread({}, entry), {
+                            steps: _to_consumable_array(entry.steps)
                         });
-                        return next;
-                    });
-                    setIsCompleted(false);
-                }
-                // Handle step status - update steps for the specific brain only
-                if (eventData.type === BRAIN_EVENTS.STEP_STATUS) {
-                    var statusEvent = eventData;
-                    setBrains(function(prev) {
-                        var next = new Map(prev);
-                        var brain = next.get(statusEvent.brainRunId);
-                        if (brain) {
-                            next.set(statusEvent.brainRunId, _object_spread_props(_object_spread({}, brain), {
-                                steps: statusEvent.steps
-                            }));
-                        }
-                        return next;
-                    });
+                    }));
                 }
-                // Handle step start - track the running step for inner brain association
-                if (eventData.type === BRAIN_EVENTS.STEP_START) {
-                    var stepEvent = eventData;
-                    runningStepIdRef.current = stepEvent.stepId;
-                }
-                // Mark brain as complete when it completes
-                if (eventData.type === BRAIN_EVENTS.COMPLETE || eventData.type === BRAIN_EVENTS.ERROR) {
-                    var completeEvent = eventData;
-                    // Mark this brain as complete
-                    setBrains(function(prev) {
-                        var next = new Map(prev);
-                        var brain = next.get(completeEvent.brainRunId);
-                        if (brain) {
-                            next.set(completeEvent.brainRunId, _object_spread_props(_object_spread({}, brain), {
-                                isComplete: true
-                            }));
-                        }
-                        return next;
-                    });
-                    // Only mark overall as complete when the main brain completes
-                    if (completeEvent.brainRunId === mainBrainRunIdRef.current) {
-                        setIsCompleted(true);
-                    }
+                // Check for completion (outer brain)
+                if (machine.context.isComplete) {
+                    setIsCompleted(true);
                 }
+                // Check for error (capture the error event for display)
                 if (eventData.type === BRAIN_EVENTS.ERROR) {
                     var errorEvent = eventData;
-                    // Only show error for the main brain
-                    if (errorEvent.brainRunId === mainBrainRunIdRef.current) {
+                    // Only show error for the main brain (isTopLevel check)
+                    if (machine.context.brainRunId === errorEvent.brainRunId) {
                         setBrainError(errorEvent);
                     }
                 }
@@ -354,12 +328,13 @@ export var Watch = function(param) {
     }, [
         runId
     ]);
-    var mainBrain = mainBrainRunIdRef.current ? brains.get(mainBrainRunIdRef.current) : null;
+    // Main brain is the first entry in the stack (outer brain)
+    var mainBrain = brainStack.length > 0 ? brainStack[0] : null;
     return /*#__PURE__*/ React.createElement(Box, {
         flexDirection: "column"
-    }, !isConnected && brains.size === 0 ? /*#__PURE__*/ React.createElement(Text, null, "Connecting to watch service...") : !mainBrain ? /*#__PURE__*/ React.createElement(Text, null, "Waiting for brain to start...") : /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(BrainSection, {
+    }, !isConnected && brainStack.length === 0 ? /*#__PURE__*/ React.createElement(Text, null, "Connecting to watch service...") : !mainBrain ? /*#__PURE__*/ React.createElement(Text, null, "Waiting for brain to start...") : /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(BrainSection, {
         brain: mainBrain,
-        brains: brains
+        brainStack: brainStack
     }), isCompleted && !error && !brainError && /*#__PURE__*/ React.createElement(Box, {
         marginTop: 1,
         borderStyle: "round",

package/dist/types/components/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../../src/components/watch.tsx"],"names":[],"mappings":"AA8LA,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,KAAK,GAAI,WAAW,UAAU,4CAsL1C,CAAC"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../../src/components/watch.tsx"],"names":[],"mappings":"AAyLA,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,eAAO,MAAM,KAAK,GAAI,WAAW,UAAU,4CAyI1C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@positronic/cli",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "publishConfig": {
     "access": "public"
   },
@@ -23,9 +23,9 @@
     "clean": "rm -rf tsconfig.tsbuildinfo dist node_modules"
   },
   "dependencies": {
-    "@positronic/core": "^0.0.46",
-    "@positronic/spec": "^0.0.46",
-    "@positronic/template-new-project": "^0.0.46",
+    "@positronic/core": "^0.0.48",
+    "@positronic/spec": "^0.0.48",
+    "@positronic/template-new-project": "^0.0.48",
     "caz": "^2.0.0",
     "chokidar": "^3.6.0",
     "dotenv": "^16.4.7",