@positronic/cli 0.0.71 → 0.0.73

package/dist/src/cli.js

@@ -162,6 +162,7 @@ import { SecretCommand } from './commands/secret.js';
 import { PagesCommand } from './commands/pages.js';
 import { UsersCommand } from './commands/users.js';
 import { AuthCommand } from './commands/auth.js';
+import { StoreCommand } from './commands/store.js';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -963,6 +964,12 @@ export function buildCli(options) {
         }).demandCommand(1, 'You need to specify a users command (list, create, delete, keys)');
         return yargsUsers;
     });
+    // --- Store Explorer Command ---
+    var storeCommand = new StoreCommand();
+    cli = cli.command('store', 'Browse and manage brain store data\n', function() {}, function() {
+        var element = storeCommand.explore();
+        render(element);
+    });
     // --- Auth Commands (Available in both local and global mode) ---
     var authCommand = new AuthCommand(undefined, projectRootPath);
     {

package/dist/src/commands/store.js

@@ -0,0 +1,36 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+import React from 'react';
+import { StoreExplorer } from '../components/store-explorer.js';
+export var StoreCommand = /*#__PURE__*/ function() {
+    "use strict";
+    function StoreCommand() {
+        _class_call_check(this, StoreCommand);
+    }
+    _create_class(StoreCommand, [
+        {
+            key: "explore",
+            value: function explore() {
+                return React.createElement(StoreExplorer);
+            }
+        }
+    ]);
+    return StoreCommand;
+}();

package/dist/src/components/store-explorer.js

@@ -0,0 +1,699 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+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 _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);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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 React, { useState, useEffect, useRef, useCallback } from 'react';
+import { Text, Box, useStdout, useInput, useApp } from 'ink';
+import { apiClient } from '../commands/helpers.js';
+import { ErrorComponent } from './error.js';
+import { StateView } from './state-view.js';
+export var StoreExplorer = function() {
+    var write = useStdout().write;
+    var exit = useApp().exit;
+    // Navigation state
+    var _useState = _sliced_to_array(useState('brains'), 2), mode = _useState[0], setMode = _useState[1];
+    var _useState1 = _sliced_to_array(useState(0), 2), selectedIndex = _useState1[0], setSelectedIndex = _useState1[1];
+    // Data state
+    var _useState2 = _sliced_to_array(useState([]), 2), brains = _useState2[0], setBrains = _useState2[1];
+    var _useState3 = _sliced_to_array(useState(null), 2), selectedBrain = _useState3[0], setSelectedBrain = _useState3[1];
+    var _useState4 = _sliced_to_array(useState([]), 2), keys = _useState4[0], setKeys = _useState4[1];
+    var _useState5 = _sliced_to_array(useState(null), 2), selectedKey = _useState5[0], setSelectedKey = _useState5[1];
+    var _useState6 = _sliced_to_array(useState(null), 2), value = _useState6[0], setValue = _useState6[1];
+    // Loading/error state
+    var _useState7 = _sliced_to_array(useState(true), 2), loading = _useState7[0], setLoading = _useState7[1];
+    var _useState8 = _sliced_to_array(useState(null), 2), error = _useState8[0], setError = _useState8[1];
+    // Delete confirmation state
+    var _useState9 = _sliced_to_array(useState(false), 2), confirmingDelete = _useState9[0], setConfirmingDelete = _useState9[1];
+    var _useState10 = _sliced_to_array(useState(false), 2), confirmingClear = _useState10[0], setConfirmingClear = _useState10[1];
+    var _useState11 = _sliced_to_array(useState(null), 2), deleteMessage = _useState11[0], setDeleteMessage = _useState11[1];
+    // Scroll state for value view
+    var _useState12 = _sliced_to_array(useState(0), 2), scrollOffset = _useState12[0], setScrollOffset = _useState12[1];
+    // Refetch trigger
+    var _useState13 = _sliced_to_array(useState(0), 2), fetchVersion = _useState13[0], setFetchVersion = _useState13[1];
+    // Use a ref to hold the latest input handler so useInput always
+    // calls through to current state, avoiding stale closure issues
+    // caused by useEffect re-registration timing in ink's useInput.
+    var inputHandlerRef = useRef(function() {});
+    // Enter alternate screen buffer on mount, exit on unmount
+    useEffect(function() {
+        if (process.env.NODE_ENV === 'test') {
+            return;
+        }
+        write('\x1B[?1049h\x1B[2J\x1B[H');
+        return function() {
+            write('\x1B[?1049l');
+        };
+    }, [
+        write
+    ]);
+    // Fetch brains list
+    useEffect(function() {
+        if (mode !== 'brains') return;
+        var fetchBrains = function() {
+            return _async_to_generator(function() {
+                var response, data, err;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            setLoading(true);
+                            setError(null);
+                            _state.label = 1;
+                        case 1:
+                            _state.trys.push([
+                                1,
+                                4,
+                                5,
+                                6
+                            ]);
+                            return [
+                                4,
+                                apiClient.fetch('/store')
+                            ];
+                        case 2:
+                            response = _state.sent();
+                            if (!response.ok) {
+                                setError({
+                                    title: 'Server Error',
+                                    message: "Failed to load store data: ".concat(response.status)
+                                });
+                                return [
+                                    2
+                                ];
+                            }
+                            return [
+                                4,
+                                response.json()
+                            ];
+                        case 3:
+                            data = _state.sent();
+                            setBrains(data.brains);
+                            return [
+                                3,
+                                6
+                            ];
+                        case 4:
+                            err = _state.sent();
+                            setError({
+                                title: 'Connection Error',
+                                message: 'Error connecting to the server.',
+                                details: err.message
+                            });
+                            return [
+                                3,
+                                6
+                            ];
+                        case 5:
+                            setLoading(false);
+                            return [
+                                7
+                            ];
+                        case 6:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        };
+        fetchBrains();
+    }, [
+        mode,
+        fetchVersion
+    ]);
+    // Fetch keys when a brain is selected
+    useEffect(function() {
+        if (mode !== 'keys' || !selectedBrain) return;
+        var fetchKeys = function() {
+            return _async_to_generator(function() {
+                var response, data, err;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            // Don't show loading spinner during background refetch after delete/clear
+                            if (!deleteMessage) {
+                                setLoading(true);
+                            }
+                            setError(null);
+                            _state.label = 1;
+                        case 1:
+                            _state.trys.push([
+                                1,
+                                4,
+                                5,
+                                6
+                            ]);
+                            return [
+                                4,
+                                apiClient.fetch("/store/".concat(encodeURIComponent(selectedBrain)))
+                            ];
+                        case 2:
+                            response = _state.sent();
+                            if (!response.ok) {
+                                setError({
+                                    title: 'Server Error',
+                                    message: "Failed to load keys: ".concat(response.status)
+                                });
+                                return [
+                                    2
+                                ];
+                            }
+                            return [
+                                4,
+                                response.json()
+                            ];
+                        case 3:
+                            data = _state.sent();
+                            setKeys(data.keys);
+                            return [
+                                3,
+                                6
+                            ];
+                        case 4:
+                            err = _state.sent();
+                            setError({
+                                title: 'Connection Error',
+                                message: 'Error connecting to the server.',
+                                details: err.message
+                            });
+                            return [
+                                3,
+                                6
+                            ];
+                        case 5:
+                            setLoading(false);
+                            return [
+                                7
+                            ];
+                        case 6:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        };
+        fetchKeys();
+    }, [
+        mode,
+        selectedBrain,
+        fetchVersion
+    ]);
+    // Fetch value when a key is selected
+    useEffect(function() {
+        if (mode !== 'value' || !selectedBrain || !selectedKey) return;
+        var fetchValue = function() {
+            return _async_to_generator(function() {
+                var scopePath, response, data, err;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            setLoading(true);
+                            setError(null);
+                            _state.label = 1;
+                        case 1:
+                            _state.trys.push([
+                                1,
+                                4,
+                                5,
+                                6
+                            ]);
+                            scopePath = selectedKey.scope === 'shared' ? 'shared' : 'user';
+                            return [
+                                4,
+                                apiClient.fetch("/store/".concat(encodeURIComponent(selectedBrain), "/").concat(scopePath, "/").concat(encodeURIComponent(selectedKey.key)))
+                            ];
+                        case 2:
+                            response = _state.sent();
+                            if (!response.ok) {
+                                setError({
+                                    title: 'Server Error',
+                                    message: "Failed to load value: ".concat(response.status)
+                                });
+                                return [
+                                    2
+                                ];
+                            }
+                            return [
+                                4,
+                                response.json()
+                            ];
+                        case 3:
+                            data = _state.sent();
+                            setValue(data);
+                            setScrollOffset(0);
+                            return [
+                                3,
+                                6
+                            ];
+                        case 4:
+                            err = _state.sent();
+                            setError({
+                                title: 'Connection Error',
+                                message: 'Error connecting to the server.',
+                                details: err.message
+                            });
+                            return [
+                                3,
+                                6
+                            ];
+                        case 5:
+                            setLoading(false);
+                            return [
+                                7
+                            ];
+                        case 6:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        };
+        fetchValue();
+    }, [
+        mode,
+        selectedBrain,
+        selectedKey,
+        fetchVersion
+    ]);
+    // Update the ref with the latest handler on every render
+    inputHandlerRef.current = function(input, key) {
+        // Clear delete message on any input
+        if (deleteMessage) {
+            setDeleteMessage(null);
+        }
+        if (mode === 'brains') {
+            if ((key.upArrow || input === 'k') && brains.length > 0) {
+                setSelectedIndex(function(prev) {
+                    return (prev - 1 + brains.length) % brains.length;
+                });
+            } else if ((key.downArrow || input === 'j') && brains.length > 0) {
+                setSelectedIndex(function(prev) {
+                    return (prev + 1) % brains.length;
+                });
+            } else if (key.return && brains.length > 0) {
+                setSelectedBrain(brains[selectedIndex]);
+                setSelectedIndex(0);
+                setMode('keys');
+            } else if (input === 'q' || key.escape) {
+                exit();
+            }
+        } else if (mode === 'keys') {
+            // Handle delete confirmation
+            if (confirmingDelete) {
+                if (input === 'y') {
+                    var keyToDelete = keys[selectedIndex];
+                    if (keyToDelete && selectedBrain) {
+                        setConfirmingDelete(false);
+                        var scopePath = keyToDelete.scope === 'shared' ? 'shared' : 'user';
+                        apiClient.fetch("/store/".concat(encodeURIComponent(selectedBrain), "/").concat(scopePath, "/").concat(encodeURIComponent(keyToDelete.key)), {
+                            method: 'DELETE'
+                        }).then(function() {
+                            setDeleteMessage("Deleted: ".concat(keyToDelete.key));
+                            setFetchVersion(function(v) {
+                                return v + 1;
+                            });
+                            if (selectedIndex >= keys.length - 1) {
+                                setSelectedIndex(Math.max(0, keys.length - 2));
+                            }
+                        });
+                    }
+                } else if (input === 'n' || key.escape) {
+                    setConfirmingDelete(false);
+                }
+                return;
+            }
+            // Handle clear confirmation
+            if (confirmingClear) {
+                if (input === 'y') {
+                    if (selectedBrain) {
+                        setConfirmingClear(false);
+                        apiClient.fetch("/store/".concat(encodeURIComponent(selectedBrain)), {
+                            method: 'DELETE'
+                        }).then(function(res) {
+                            return _async_to_generator(function() {
+                                var data;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                res.json()
+                                            ];
+                                        case 1:
+                                            data = _state.sent();
+                                            setDeleteMessage("Cleared ".concat(data.deleted, " keys"));
+                                            setFetchVersion(function(v) {
+                                                return v + 1;
+                                            });
+                                            setSelectedIndex(0);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        });
+                    }
+                } else if (input === 'n' || key.escape) {
+                    setConfirmingClear(false);
+                }
+                return;
+            }
+            // Normal key list navigation
+            if ((key.upArrow || input === 'k') && keys.length > 0) {
+                setSelectedIndex(function(prev) {
+                    return (prev - 1 + keys.length) % keys.length;
+                });
+            } else if ((key.downArrow || input === 'j') && keys.length > 0) {
+                setSelectedIndex(function(prev) {
+                    return (prev + 1) % keys.length;
+                });
+            } else if (key.return && keys.length > 0) {
+                setSelectedKey(keys[selectedIndex]);
+                setMode('value');
+            } else if (input === 'd' && keys.length > 0) {
+                setConfirmingDelete(true);
+            } else if (input === 'c' && keys.length > 0) {
+                setConfirmingClear(true);
+            } else if (input === 'b' || key.escape) {
+                setSelectedBrain(null);
+                setSelectedIndex(0);
+                setMode('brains');
+            }
+        } else if (mode === 'value') {
+            // Value view - StateView handles j/k/space scrolling via isActive
+            if (input === 'b' || key.escape) {
+                setSelectedKey(null);
+                setValue(null);
+                setMode('keys');
+            }
+        }
+    };
+    // Stable callback that delegates to the ref - never changes identity,
+    // so ink's useInput useEffect won't need to re-register the listener.
+    var stableInputHandler = useCallback(function(input, key) {
+        inputHandlerRef.current(input, key);
+    }, []);
+    // Keyboard handling - uses stable callback to avoid stale closure issues
+    useInput(stableInputHandler, {
+        isActive: mode !== 'value'
+    });
+    // Adjust selectedIndex if list shrinks
+    useEffect(function() {
+        var listLength = mode === 'brains' ? brains.length : mode === 'keys' ? keys.length : 0;
+        if (listLength > 0 && selectedIndex >= listLength) {
+            setSelectedIndex(listLength - 1);
+        }
+    }, [
+        brains.length,
+        keys.length,
+        selectedIndex,
+        mode
+    ]);
+    // Error state
+    if (error) {
+        return /*#__PURE__*/ React.createElement(ErrorComponent, {
+            error: error
+        });
+    }
+    // Loading state - skip when there's a delete message so it stays visible
+    if (loading && !deleteMessage) {
+        return /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, null, "Loading..."));
+    }
+    // Value view
+    if (mode === 'value' && value) {
+        var stateObj = _type_of(value.value) === 'object' && value.value !== null ? value.value : {
+            value: value.value
+        };
+        var title = "".concat(selectedBrain, " / ").concat(value.key, " (").concat(value.scope, ")");
+        return /*#__PURE__*/ React.createElement(Box, {
+            flexDirection: "column"
+        }, /*#__PURE__*/ React.createElement(StateView, {
+            state: stateObj,
+            title: title,
+            scrollOffset: scrollOffset,
+            onScrollChange: setScrollOffset,
+            isActive: true
+        }), /*#__PURE__*/ React.createElement(Box, {
+            marginTop: 1
+        }, /*#__PURE__*/ React.createElement(Text, {
+            dimColor: true
+        }, "j/k scroll | space page | b back")));
+    }
+    // Keys view
+    if (mode === 'keys' && selectedBrain) {
+        if (keys.length === 0) {
+            return /*#__PURE__*/ React.createElement(Box, {
+                flexDirection: "column"
+            }, /*#__PURE__*/ React.createElement(Box, {
+                marginBottom: 1
+            }, /*#__PURE__*/ React.createElement(Text, {
+                bold: true,
+                color: "cyan"
+            }, "Store: ", selectedBrain)), deleteMessage && /*#__PURE__*/ React.createElement(Box, null, /*#__PURE__*/ React.createElement(Text, {
+                color: "green"
+            }, deleteMessage)), /*#__PURE__*/ React.createElement(Text, {
+                dimColor: true
+            }, "No keys found"), /*#__PURE__*/ React.createElement(Box, {
+                marginTop: 1
+            }, /*#__PURE__*/ React.createElement(Text, {
+                dimColor: true
+            }, "b back | q quit")));
+        }
+        var footer;
+        if (confirmingDelete) {
+            var keyEntry = keys[selectedIndex];
+            footer = 'Delete "'.concat(keyEntry === null || keyEntry === void 0 ? void 0 : keyEntry.key, '"? (y/n)');
+        } else if (confirmingClear) {
+            footer = 'Clear all keys for "'.concat(selectedBrain, '"? (y/n)');
+        } else {
+            footer = 'j/k select | Enter view | d delete | c clear all | b back';
+        }
+        return /*#__PURE__*/ React.createElement(Box, {
+            flexDirection: "column"
+        }, /*#__PURE__*/ React.createElement(Box, {
+            marginBottom: 1
+        }, /*#__PURE__*/ React.createElement(Text, {
+            bold: true,
+            color: "cyan"
+        }, "Store: ", selectedBrain, " (", keys.length, " keys)")), keys.map(function(entry, i) {
+            return /*#__PURE__*/ React.createElement(Box, {
+                key: "".concat(entry.scope, "-").concat(entry.key, "-").concat(entry.userId || '')
+            }, /*#__PURE__*/ React.createElement(Text, {
+                color: i === selectedIndex ? 'cyan' : undefined
+            }, i === selectedIndex ? '> ' : '  ', entry.key, /*#__PURE__*/ React.createElement(Text, {
+                dimColor: true
+            }, ' ', "[", entry.scope, entry.userId ? ":".concat(entry.userId) : '', "] ", entry.size, "B")));
+        }), deleteMessage && /*#__PURE__*/ React.createElement(Box, {
+            marginTop: 1
+        }, /*#__PURE__*/ React.createElement(Text, {
+            color: "green"
+        }, deleteMessage)), /*#__PURE__*/ React.createElement(Box, {
+            marginTop: 1
+        }, /*#__PURE__*/ React.createElement(Text, {
+            dimColor: true
+        }, footer)));
+    }
+    // Brains view (default)
+    if (brains.length === 0) {
+        return /*#__PURE__*/ React.createElement(Box, {
+            flexDirection: "column"
+        }, /*#__PURE__*/ React.createElement(Box, {
+            marginBottom: 1
+        }, /*#__PURE__*/ React.createElement(Text, {
+            bold: true,
+            color: "cyan"
+        }, "Store Explorer")), /*#__PURE__*/ React.createElement(Text, {
+            dimColor: true
+        }, "No brains with store data found"), /*#__PURE__*/ React.createElement(Box, {
+            marginTop: 1
+        }, /*#__PURE__*/ React.createElement(Text, {
+            dimColor: true
+        }, "Use .withStore() in your brain definition to persist data")));
+    }
+    return /*#__PURE__*/ React.createElement(Box, {
+        flexDirection: "column"
+    }, /*#__PURE__*/ React.createElement(Box, {
+        marginBottom: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        bold: true,
+        color: "cyan"
+    }, "Store Explorer (", brains.length, " brains)")), brains.map(function(brain, i) {
+        return /*#__PURE__*/ React.createElement(Box, {
+            key: brain
+        }, /*#__PURE__*/ React.createElement(Text, {
+            color: i === selectedIndex ? 'cyan' : undefined
+        }, i === selectedIndex ? '> ' : '  ', brain));
+    }), /*#__PURE__*/ React.createElement(Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ React.createElement(Text, {
+        dimColor: true
+    }, "j/k select | Enter explore | q quit")));
+};

package/dist/types/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAU1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAK5D,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,KAAK,GAAG,CAAC;IAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAoBD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,UAAU,4BAi7C3C"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAW1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAK5D,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,KAAK,GAAG,CAAC;IAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAoBD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,UAAU,4BA67C3C"}

package/dist/types/commands/store.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare class StoreCommand {
+    explore(): React.ReactElement;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/types/commands/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/commands/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,qBAAa,YAAY;IACvB,OAAO,IAAI,KAAK,CAAC,YAAY;CAG9B"}

package/dist/types/components/store-explorer.d.ts

@@ -0,0 +1,2 @@
+export declare const StoreExplorer: () => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=store-explorer.d.ts.map

package/dist/types/components/store-explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-explorer.d.ts","sourceRoot":"","sources":["../../../src/components/store-explorer.tsx"],"names":[],"mappings":"AA0CA,eAAO,MAAM,aAAa,+CA8ZzB,CAAC"}

package/package.json

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