@positronic/cli 0.0.38 → 0.0.39

package/dist/src/commands/brain.js

@@ -1,32 +1,3 @@
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -46,134 +17,16 @@ function _create_class(Constructor, protoProps, staticProps) {
     if (staticProps) _defineProperties(Constructor, staticProps);
     return Constructor;
 }
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-}
-import { apiClient, isApiLocalDevMode } from './helpers.js';
 import React from 'react';
-import { Text } from 'ink';
 import { Watch } from '../components/watch.js';
 import { BrainList } from '../components/brain-list.js';
 import { BrainHistory } from '../components/brain-history.js';
 import { RunShow } from '../components/run-show.js';
 import { BrainRerun } from '../components/brain-rerun.js';
 import { BrainKill } from '../components/brain-kill.js';
+import { BrainRun } from '../components/brain-run.js';
+import { BrainResolver } from '../components/brain-resolver.js';
+import { BrainWatchWithResolver } from '../components/brain-watch.js';
 import { ErrorComponent } from '../components/error.js';
 export var BrainCommand = /*#__PURE__*/ function() {
     "use strict";
@@ -190,10 +43,15 @@ export var BrainCommand = /*#__PURE__*/ function() {
         {
             key: "history",
             value: function history(param) {
-                var filename = param.filename, limit = param.limit;
-                return React.createElement(BrainHistory, {
-                    brainName: filename,
-                    limit: limit
+                var brain = param.brain, limit = param.limit;
+                return React.createElement(BrainResolver, {
+                    identifier: brain,
+                    children: function(resolvedBrainTitle) {
+                        return React.createElement(BrainHistory, {
+                            brainName: resolvedBrainTitle,
+                            limit: limit
+                        });
+                    }
                 });
             }
         },
@@ -209,272 +67,56 @@ export var BrainCommand = /*#__PURE__*/ function() {
         {
             key: "rerun",
             value: function rerun(param) {
-                var filename = param.filename, runId = param.runId, startsAt = param.startsAt, stopsAfter = param.stopsAfter;
-                return React.createElement(BrainRerun, {
-                    identifier: filename,
-                    runId: runId,
-                    startsAt: startsAt,
-                    stopsAfter: stopsAfter
+                var brain = param.brain, runId = param.runId, startsAt = param.startsAt, stopsAfter = param.stopsAfter;
+                return React.createElement(BrainResolver, {
+                    identifier: brain,
+                    children: function(resolvedBrainTitle) {
+                        return React.createElement(BrainRerun, {
+                            identifier: resolvedBrainTitle,
+                            runId: runId,
+                            startsAt: startsAt,
+                            stopsAfter: stopsAfter
+                        });
+                    }
                 });
             }
         },
         {
             key: "run",
-            value: function run(_0) {
-                return _async_to_generator(function(param) {
-                    var filename, watch, options, apiPath, response, result, errorText, error;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                filename = param.filename, watch = param.watch, options = param.options;
-                                apiPath = '/brains/runs';
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    8,
-                                    ,
-                                    9
-                                ]);
-                                return [
-                                    4,
-                                    apiClient.fetch(apiPath, {
-                                        method: 'POST',
-                                        headers: {
-                                            'Content-Type': 'application/json'
-                                        },
-                                        body: JSON.stringify({
-                                            identifier: filename,
-                                            options: options
-                                        })
-                                    })
-                                ];
-                            case 2:
-                                response = _state.sent();
-                                if (!(response.status === 201)) return [
-                                    3,
-                                    4
-                                ];
-                                return [
-                                    4,
-                                    response.json()
-                                ];
-                            case 3:
-                                result = _state.sent();
-                                if (watch) {
-                                    // Return Watch component for CLI to render
-                                    return [
-                                        2,
-                                        this.watch({
-                                            runId: result.brainRunId,
-                                            _: [],
-                                            $0: ''
-                                        })
-                                    ];
-                                } else {
-                                    // Return React element displaying the run ID
-                                    return [
-                                        2,
-                                        React.createElement(Text, null, "Run ID: ".concat(result.brainRunId))
-                                    ];
-                                }
-                                return [
-                                    3,
-                                    7
-                                ];
-                            case 4:
-                                if (!(response.status === 404)) return [
-                                    3,
-                                    5
-                                ];
-                                // Handle brain not found with a helpful message
-                                return [
-                                    2,
-                                    React.createElement(ErrorComponent, {
-                                        error: {
-                                            title: 'Brain Not Found',
-                                            message: "Brain '".concat(filename, "' not found."),
-                                            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'
-                                        }
-                                    })
-                                ];
-                            case 5:
-                                return [
-                                    4,
-                                    response.text()
-                                ];
-                            case 6:
-                                errorText = _state.sent();
-                                console.error("Error starting brain run: ".concat(response.status, " ").concat(response.statusText));
-                                console.error("Server response: ".concat(errorText));
-                                process.exit(1);
-                                _state.label = 7;
-                            case 7:
-                                return [
-                                    3,
-                                    9
-                                ];
-                            case 8:
-                                error = _state.sent();
-                                if (isApiLocalDevMode()) {
-                                    console.error("Error connecting to the local development server.");
-                                    console.error("Please ensure the server is running ('positronic server' or 'px s').");
-                                } else {
-                                    console.error("Error connecting to the remote project server.");
-                                    console.error('Please check your network connection and verify the project URL is correct.');
-                                }
-                                if (error.code === 'ECONNREFUSED') {
-                                    console.error('Reason: Connection refused. The server might not be running or is listening on a different port.');
-                                } else {
-                                    console.error("Fetch error details: ".concat(error.message));
-                                }
-                                process.exit(1);
-                                return [
-                                    3,
-                                    9
-                                ];
-                            case 9:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                }).apply(this, arguments);
+            value: function run(param) {
+                var brain = param.brain, watch = param.watch, options = param.options;
+                return React.createElement(BrainRun, {
+                    identifier: brain,
+                    watch: watch,
+                    options: options
+                });
             }
         },
         {
             key: "watch",
-            value: function watch(_0) {
-                return _async_to_generator(function(param) {
-                    var runId, filename, apiPath, response, result, activeRun, errorText, error, connectionError;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                runId = param.runId, filename = param.filename;
-                                // If a specific run ID is provided, return the Watch component
-                                if (runId) {
-                                    return [
-                                        2,
-                                        React.createElement(Watch, {
-                                            runId: runId
-                                        })
-                                    ];
-                                }
-                                if (!filename) return [
-                                    3,
-                                    8
-                                ];
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    7,
-                                    ,
-                                    8
-                                ]);
-                                apiPath = "/brains/".concat(encodeURIComponent(filename), "/active-runs");
-                                return [
-                                    4,
-                                    apiClient.fetch(apiPath, {
-                                        method: 'GET'
-                                    })
-                                ];
-                            case 2:
-                                response = _state.sent();
-                                if (!(response.status === 200)) return [
-                                    3,
-                                    4
-                                ];
-                                return [
-                                    4,
-                                    response.json()
-                                ];
-                            case 3:
-                                result = _state.sent();
-                                if (result.runs.length === 0) {
-                                    return [
-                                        2,
-                                        React.createElement(ErrorComponent, {
-                                            error: {
-                                                title: 'No Active Runs',
-                                                message: 'No currently running brain runs found for brain "'.concat(filename, '".'),
-                                                details: "To start a new run, use: positronic run ".concat(filename)
-                                            }
-                                        })
-                                    ];
-                                }
-                                if (result.runs.length > 1) {
-                                    return [
-                                        2,
-                                        React.createElement(ErrorComponent, {
-                                            error: {
-                                                title: 'Multiple Active Runs',
-                                                message: "Found ".concat(result.runs.length, ' active runs for brain "').concat(filename, '".'),
-                                                details: "Please specify a specific run ID with --run-id:\n".concat(result.runs.map(function(run) {
-                                                    return "  positronic watch --run-id ".concat(run.brainRunId);
-                                                }).join('\n'))
-                                            }
-                                        })
-                                    ];
-                                }
-                                // Exactly one active run found - watch it
-                                activeRun = result.runs[0];
-                                return [
-                                    2,
-                                    React.createElement(Watch, {
-                                        runId: activeRun.brainRunId
-                                    })
-                                ];
-                            case 4:
-                                return [
-                                    4,
-                                    response.text()
-                                ];
-                            case 5:
-                                errorText = _state.sent();
-                                return [
-                                    2,
-                                    React.createElement(ErrorComponent, {
-                                        error: {
-                                            title: 'API Error',
-                                            message: 'Failed to get active runs for brain "'.concat(filename, '".'),
-                                            details: "Server returned ".concat(response.status, ": ").concat(errorText)
-                                        }
-                                    })
-                                ];
-                            case 6:
-                                return [
-                                    3,
-                                    8
-                                ];
-                            case 7:
-                                error = _state.sent();
-                                connectionError = isApiLocalDevMode() ? {
-                                    message: 'Error connecting to the local development server.',
-                                    details: "Please ensure the server is running ('positronic server' or 'px s').\n\nError details: ".concat(error.message)
-                                } : {
-                                    message: 'Error connecting to the remote project server.',
-                                    details: "Please check your network connection and verify the project URL is correct.\n\nError details: ".concat(error.message)
-                                };
-                                return [
-                                    2,
-                                    React.createElement(ErrorComponent, {
-                                        error: _object_spread({
-                                            title: 'Connection Error'
-                                        }, connectionError)
-                                    })
-                                ];
-                            case 8:
-                                // Neither runId nor brainName provided – return an error element.
-                                return [
-                                    2,
-                                    React.createElement(Text, {
-                                        color: 'red'
-                                    }, 'Error: You must provide either a brain run ID or a brain name.')
-                                ];
-                        }
+            value: function watch(param) {
+                var runId = param.runId, brain = param.brain;
+                // If a specific run ID is provided, return the Watch component
+                if (runId) {
+                    return React.createElement(Watch, {
+                        runId: runId
                     });
-                }).apply(this, arguments);
+                }
+                // If watching by brain identifier is requested, use BrainWatchWithResolver
+                // which handles fuzzy search, disambiguation, and active run lookup
+                if (brain) {
+                    return React.createElement(BrainWatchWithResolver, {
+                        identifier: brain
+                    });
+                }
+                // Neither runId nor brainName provided – return an error element.
+                return React.createElement(ErrorComponent, {
+                    error: {
+                        title: 'Missing Argument',
+                        message: 'You must provide either a brain run ID or a brain identifier.',
+                        details: 'Use --run-id to watch a specific run, or --brain to watch the active run of a brain.'
+                    }
+                });
             }
         },
         {

package/dist/src/commands/schedule.js

@@ -22,6 +22,7 @@ import { ScheduleCreate } from '../components/schedule-create.js';
 import { ScheduleList } from '../components/schedule-list.js';
 import { ScheduleDelete } from '../components/schedule-delete.js';
 import { ScheduleRuns } from '../components/schedule-runs.js';
+import { BrainResolver } from '../components/brain-resolver.js';
 export var ScheduleCommand = /*#__PURE__*/ function() {
     "use strict";
     function ScheduleCommand() {
@@ -31,10 +32,15 @@ export var ScheduleCommand = /*#__PURE__*/ function() {
         {
             key: "create",
             value: function create(param) {
-                var brainFilename = param.brainFilename, cronExpression = param.cronExpression;
-                return React.createElement(ScheduleCreate, {
-                    identifier: brainFilename,
-                    cronExpression: cronExpression
+                var brain = param.brain, cronExpression = param.cronExpression;
+                return React.createElement(BrainResolver, {
+                    identifier: brain,
+                    children: function(resolvedBrainTitle) {
+                        return React.createElement(ScheduleCreate, {
+                            identifier: resolvedBrainTitle,
+                            cronExpression: cronExpression
+                        });
+                    }
                 });
             }
         },

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

@@ -27,15 +27,49 @@ import React from 'react';
 import { Text, Box } from 'ink';
 import { ErrorComponent } from './error.js';
 import { useApiGet } from '../hooks/useApi.js';
-// Helper to truncate text to fit column width
-var truncate = function(text, maxWidth) {
-    if (text.length <= maxWidth) return text;
-    return text.substring(0, maxWidth - 3) + '...';
-};
 // Helper to pad text to column width
 var padRight = function(text, width) {
     return text + ' '.repeat(Math.max(0, width - text.length));
 };
+// Helper to wrap text to multiple lines
+var wrapText = function(text, maxWidth) {
+    var words = text.split(' ');
+    var lines = [];
+    var currentLine = '';
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = words[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var word = _step.value;
+            if (currentLine.length === 0) {
+                currentLine = word;
+            } else if (currentLine.length + 1 + word.length <= maxWidth) {
+                currentLine += ' ' + word;
+            } else {
+                lines.push(currentLine);
+                currentLine = word;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (currentLine.length > 0) {
+        lines.push(currentLine);
+    }
+    return lines.length > 0 ? lines : [
+        ''
+    ];
+};
 export var BrainList = function() {
     var _useApiGet = useApiGet('/brains'), data = _useApiGet.data, loading = _useApiGet.loading, error = _useApiGet.error;
     if (error) {
@@ -55,23 +89,19 @@ export var BrainList = function() {
             dimColor: true
         }, 'Tip: Create a brain with "px brain new <name>" or add .ts files to the brains/ directory')));
     }
-    // Sort brains alphabetically by filename
+    // Sort brains alphabetically by title
     var sortedBrains = _to_consumable_array(data.brains).sort(function(a, b) {
-        return a.filename.localeCompare(b.filename);
+        return a.title.localeCompare(b.title);
     });
     // Define column widths
     var columns = {
-        filename: {
-            header: 'Filename',
-            width: 25
-        },
         title: {
-            header: 'Title',
-            width: 35
+            header: 'Brain',
+            width: 25
         },
         description: {
             header: 'Description',
-            width: 50
+            width: 70
         }
     };
     // Calculate total width for separator
@@ -90,19 +120,25 @@ export var BrainList = function() {
     }, /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, {
         bold: true,
         color: "cyan"
-    }, padRight(columns.filename.header, columns.filename.width)), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, {
-        bold: true,
-        color: "cyan"
     }, padRight(columns.title.header, columns.title.width)), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, {
         bold: true,
         color: "cyan"
-    }, padRight(columns.description.header, columns.description.width))), /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, {
+    }, columns.description.header)), /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, {
         dimColor: true
     }, '─'.repeat(totalWidth))), sortedBrains.map(function(brain) {
+        var descriptionLines = wrapText(brain.description, columns.description.width);
         return /*#__PURE__*/ React.createElement(Box, {
-            key: brain.filename
-        }, /*#__PURE__*/ React.createElement(Text, null, padRight(truncate(brain.filename, columns.filename.width), columns.filename.width)), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, null, padRight(truncate(brain.title, columns.title.width), columns.title.width)), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, {
+            key: brain.filename,
+            flexDirection: "column",
+            marginBottom: descriptionLines.length > 1 ? 1 : 0
+        }, /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, null, padRight(brain.title.length > columns.title.width ? brain.title.substring(0, columns.title.width - 3) + '...' : brain.title, columns.title.width)), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, {
             dimColor: true
-        }, padRight(truncate(brain.description, columns.description.width), columns.description.width)));
+        }, descriptionLines[0])), descriptionLines.slice(1).map(function(line, index) {
+            return /*#__PURE__*/ React.createElement(Box, {
+                key: index
+            }, /*#__PURE__*/ React.createElement(Text, null, ' '.repeat(columns.title.width)), /*#__PURE__*/ React.createElement(Text, null, "  "), /*#__PURE__*/ React.createElement(Text, {
+                dimColor: true
+            }, line));
+        }));
     })));
 };