@positronic/cli 0.0.2

package/dist/src/cli.js

@@ -0,0 +1,739 @@
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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 yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { ProjectCommand } from './commands/project.js';
+import { ServerCommand } from './commands/server.js';
+import { BrainCommand } from './commands/brain.js';
+import { ResourcesCommand } from './commands/resources.js';
+import { ScheduleCommand } from './commands/schedule.js';
+import { SecretCommand } from './commands/secret.js';
+export function buildCli(options) {
+    var _options_argv = options.argv, argv = _options_argv === void 0 ? hideBin(process.argv) : _options_argv, server = options.server, _options_exitProcess = options.exitProcess, exitProcess = _options_exitProcess === void 0 ? false : _options_exitProcess, render = options.render;
+    var isLocalDevMode = server !== undefined;
+    // Instantiate command classes, passing the determined mode and path
+    var projectCommand = new ProjectCommand();
+    var brainCommand = new BrainCommand();
+    var scheduleCommand = new ScheduleCommand();
+    var secretCommand = new SecretCommand(server);
+    // Main CLI definition
+    var cli = yargs(argv).scriptName('positronic').usage('Usage: $0 <command> [options]').version().alias('v', 'version').help('h').alias('h', 'help').wrap(null).strictCommands().exitProcess(exitProcess);
+    // --- Project Management Commands (Global Mode Only) ---
+    cli = cli.command('project', 'Manage your Positronic projects\n', function(yargsProject) {
+        if (!isLocalDevMode) {
+            yargsProject.command('new <name>', 'Create a new Positronic project directory', function(yargsNew) {
+                return yargsNew.positional('name', {
+                    describe: 'Name of the new project directory to create',
+                    type: 'string',
+                    demandOption: true
+                });
+            }, function(argv) {
+                var element = projectCommand.create(argv);
+                render(element);
+            });
+        }
+        yargsProject.command('add <name>', 'Add a project to your list of projects', function(yargsAdd) {
+            return yargsAdd.positional('name', {
+                describe: 'Name for the project',
+                type: 'string',
+                demandOption: true
+            }).option('url', {
+                describe: 'Project API URL',
+                type: 'string',
+                demandOption: true
+            }).example('$0 project add my-project --url https://api.my-project.positronic.sh', 'Add a project configuration');
+        }, function(argv) {
+            var element = projectCommand.add(argv);
+            render(element);
+        }).command('select [name]', 'Switch the active project', function(yargsSelect) {
+            return yargsSelect.positional('name', {
+                describe: 'Project name to select',
+                type: 'string'
+            }).example('$0 project select my-project', 'Switch the active project').example('$0 project select', 'Interactive project selection');
+        }, function(argv) {
+            var element = projectCommand.select(argv);
+            render(element);
+        }).command('list', 'List all of your Positronic projects', function() {}, function() {
+            var element = projectCommand.list();
+            render(element);
+        }).command('show', 'Display your currently selected project', function() {}, function() {
+            var element = projectCommand.show();
+            render(element);
+        }).command('rm <name>', 'Remove a project from your list of projects', function(yargsRm) {
+            return yargsRm.positional('name', {
+                describe: 'Name of the project to remove',
+                type: 'string',
+                demandOption: true
+            }).example('$0 project rm my-project', 'Remove a project configuration');
+        }, function(argv) {
+            var element = projectCommand.remove(argv);
+            render(element);
+        }).demandCommand(1, 'You need to specify a project command (add, select, list, show, rm) in Local Dev Mode.');
+        return yargsProject;
+    });
+    // --- Add the 'new' command alias (Global Mode Only) ---
+    if (!isLocalDevMode) {
+        cli = cli.command('new <name>', 'Alias for `project new`. Create a new Positronic project directory.\n', function(yargsNewAlias) {
+            return yargsNewAlias.positional('name', {
+                describe: 'Name of the new project directory to create',
+                type: 'string',
+                demandOption: true
+            });
+        }, function(argv) {
+            var element = projectCommand.create(argv);
+            render(element);
+        });
+    }
+    // --- Add the Server Command ---
+    // The server command should only be available in local dev mode;
+    // Wrap its registration in the check
+    if (isLocalDevMode) {
+        var serverCommand = new ServerCommand(server);
+        cli = cli.command([
+            'server',
+            's'
+        ], 'Start the local development server for the current project', function(yargsServer) {
+            return yargsServer.option('force', {
+                describe: 'Force regeneration of the .positronic server directory',
+                type: 'boolean',
+                default: false
+            }).option('port', {
+                describe: 'Port number for the server to listen on',
+                type: 'number',
+                alias: 'p'
+            }).option('log-file', {
+                describe: 'File to redirect server output to (for AI agents)',
+                type: 'string',
+                alias: 'l'
+            }).option('d', {
+                describe: 'Run server in detached/background mode',
+                type: 'boolean',
+                default: false
+            }).option('k', {
+                describe: 'Kill the default background server',
+                type: 'boolean',
+                default: false
+            });
+        }, function(argv) {
+            return serverCommand.handle(argv);
+        });
+        // Add deploy command (only in local dev mode)
+        cli = cli.command('deploy', 'Deploy the project to production', function() {}, function() {
+            return _async_to_generator(function() {
+                var error;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            _state.trys.push([
+                                0,
+                                2,
+                                ,
+                                3
+                            ]);
+                            // Deploy
+                            return [
+                                4,
+                                server.deploy()
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                3,
+                                3
+                            ];
+                        case 2:
+                            error = _state.sent();
+                            console.error('Deployment failed:', _instanceof(error, Error) ? error.message : String(error));
+                            process.exit(1);
+                            return [
+                                3,
+                                3
+                            ];
+                        case 3:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+    }
+    // --- List Brains Command ---
+    cli = cli.command('list', 'List all brains in the active project\n', function() {}, function(argv) {
+        var element = brainCommand.list(argv);
+        render(element);
+    });
+    // --- Brain History Command ---
+    cli = cli.command('history <name>', 'List recent runs of a specific brain\n', function(yargsHistory) {
+        return yargsHistory.positional('name', {
+            describe: 'Name of the brain',
+            type: 'string',
+            demandOption: true
+        }).option('limit', {
+            describe: 'Maximum number of runs to show',
+            type: 'number',
+            default: 10
+        }).example('$0 history my-brain', 'List recent runs for my-brain').example('$0 history my-brain --limit=20', 'List more recent runs');
+    }, function(argv) {
+        var element = brainCommand.history(argv);
+        render(element);
+    });
+    // --- Show Brain Command ---
+    cli = cli.command('show <name>', 'List all steps and other details for the brain\n', function(yargsShow) {
+        return yargsShow.positional('name', {
+            describe: 'Name of the brain',
+            type: 'string',
+            demandOption: true
+        });
+    }, function(argv) {
+        var element = brainCommand.show(argv);
+        render(element);
+    });
+    // --- Rerun Brain Command ---
+    cli = cli.command('rerun <name> [run-id]', 'Rerun an existing brain run\n', function(yargsRerun) {
+        return yargsRerun.positional('name', {
+            describe: 'Name of the brain',
+            type: 'string',
+            demandOption: true
+        }).positional('run-id', {
+            describe: 'ID of the brain run to rerun (defaults to the most recent run)',
+            type: 'string'
+        }).option('starts-at', {
+            describe: 'Step number to start execution from',
+            type: 'number'
+        }).alias('starts-at', 's').option('stops-after', {
+            describe: 'Step number to stop execution after',
+            type: 'number'
+        }).alias('stops-after', 'e').example('$0 rerun my-brain', 'Rerun the most recent execution of my-brain').example('$0 rerun my-brain abc123', 'Rerun a specific brain run').example('$0 rerun my-brain --starts-at=3', 'Rerun from step 3').example('$0 rerun my-brain --stops-after=5', 'Rerun and stop after step 5').example('$0 rerun my-brain --starts-at=3 --stops-after=5', 'Rerun steps 3 through 5');
+    }, function(argv) {
+        var element = brainCommand.rerun(argv);
+        render(element);
+    });
+    // --- Run Brain Command ---
+    cli = cli.command('run <name>', 'Run a brain and optionally watch its execution\n', function(yargsRun) {
+        return yargsRun.positional('name', {
+            describe: 'Name of the brain',
+            type: 'string',
+            demandOption: true
+        }).option('watch', {
+            describe: 'Watch the brain run immediately after starting',
+            type: 'boolean',
+            alias: 'w',
+            default: false
+        }).example('$0 run my-brain', 'Run a brain by name').example('$0 run my-brain --watch', 'Run a brain and watch its execution');
+    }, function(argv) {
+        return _async_to_generator(function() {
+            var element;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            brainCommand.run(argv)
+                        ];
+                    case 1:
+                        element = _state.sent();
+                        if (element) {
+                            render(element);
+                        }
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    // --- Watch Brain Run Command ---
+    cli = cli.command('watch [name]', 'Watch a brain run: latest by name (default) or specific by ID\n', function(yargsWatch) {
+        return yargsWatch.positional('name', {
+            describe: 'Name of the brain to watch (watches the most recent run)',
+            type: 'string'
+        }).option('run-id', {
+            describe: 'ID of the specific brain run to watch',
+            type: 'string',
+            alias: 'id'
+        }).conflicts('name', 'run-id').check(function(argv) {
+            if (!argv.name && !argv.runId) {
+                throw new Error('You must provide either a brain name or a --run-id.');
+            }
+            return true;
+        }).example('$0 watch my-brain', "Watch the latest run of the brain named 'my-brain'").example('$0 watch --run-id abc123def', 'Watch a specific brain run by its ID');
+    }, function(argv) {
+        return _async_to_generator(function() {
+            var element;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            brainCommand.watch(argv)
+                        ];
+                    case 1:
+                        element = _state.sent();
+                        if (element) {
+                            render(element);
+                        }
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    // --- Brain Commands ---
+    cli = cli.command('brain', 'Manage your brains\n', function(yargsBrain) {
+        yargsBrain.command('list', 'List all brains in the active project\n', function() {}, function(argv) {
+            var element = brainCommand.list(argv);
+            render(element);
+        }).command('history <name>', 'List recent runs of a specific brain\n', function(yargsHistory) {
+            return yargsHistory.positional('name', {
+                describe: 'Name of the brain',
+                type: 'string',
+                demandOption: true
+            }).option('limit', {
+                describe: 'Maximum number of runs to show',
+                type: 'number',
+                default: 10
+            }).example('$0 brain history my-brain', 'List recent runs for my-brain').example('$0 brain history my-brain --limit=20', 'List more recent runs');
+        }, function(argv) {
+            var element = brainCommand.history(argv);
+            render(element);
+        }).command('show <name>', 'List all steps and other details for the brain\n', function(yargsShow) {
+            return yargsShow.positional('name', {
+                describe: 'Name of the brain',
+                type: 'string',
+                demandOption: true
+            });
+        }, function(argv) {
+            var element = brainCommand.show(argv);
+            render(element);
+        }).command('rerun <name> [run-id]', 'Rerun an existing brain run\n', function(yargsRerun) {
+            return yargsRerun.positional('name', {
+                describe: 'Name of the brain',
+                type: 'string',
+                demandOption: true
+            }).positional('run-id', {
+                describe: 'ID of the brain run to rerun (defaults to the most recent run)',
+                type: 'string'
+            }).option('starts-at', {
+                describe: 'Step number to start execution from',
+                type: 'number'
+            }).alias('starts-at', 's').option('stops-after', {
+                describe: 'Step number to stop execution after',
+                type: 'number'
+            }).alias('stops-after', 'e').example('$0 brain rerun my-brain', 'Rerun the most recent execution of my-brain').example('$0 brain rerun my-brain abc123', 'Rerun a specific brain run').example('$0 brain rerun my-brain --starts-at=3', 'Rerun from step 3').example('$0 brain rerun my-brain --stops-after=5', 'Rerun and stop after step 5').example('$0 brain rerun my-brain --starts-at=3 --stops-after=5', 'Rerun steps 3 through 5');
+        }, function(argv) {
+            var element = brainCommand.rerun(argv);
+            render(element);
+        }).command('run <name>', 'Run a brain and optionally watch its execution\n', function(yargsRun) {
+            return yargsRun.positional('name', {
+                describe: 'Name of the brain',
+                type: 'string',
+                demandOption: true
+            }).option('watch', {
+                describe: 'Watch the brain run immediately after starting',
+                type: 'boolean',
+                alias: 'w',
+                default: false
+            }).example('$0 brain run my-brain', 'Run a brain by name').example('$0 brain run my-brain --watch', 'Run a brain and watch its execution');
+        }, function(argv) {
+            return _async_to_generator(function() {
+                var element;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                brainCommand.run(argv)
+                            ];
+                        case 1:
+                            element = _state.sent();
+                            if (element) {
+                                render(element);
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }).command('watch [name]', 'Watch a brain run: latest by name (default) or specific by ID\n', function(yargsWatch) {
+            return yargsWatch.positional('name', {
+                describe: 'Name of the brain to watch (watches the most recent run)',
+                type: 'string'
+            }).option('run-id', {
+                describe: 'ID of the specific brain run to watch',
+                type: 'string',
+                alias: 'id'
+            }).conflicts('name', 'run-id').check(function(argv) {
+                if (!argv.name && !argv.runId) {
+                    throw new Error('You must provide either a brain name or a --run-id.');
+                }
+                return true;
+            }).example('$0 brain watch my-brain', "Watch the latest run of the brain named 'my-brain'").example('$0 brain watch --run-id abc123def', 'Watch a specific brain run by its ID');
+        }, function(argv) {
+            return _async_to_generator(function() {
+                var element;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                brainCommand.watch(argv)
+                            ];
+                        case 1:
+                            element = _state.sent();
+                            if (element) {
+                                render(element);
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }).demandCommand(1, 'You need to specify a brain command (list, history, show, rerun, run, watch).');
+        return yargsBrain;
+    });
+    // --- Resource Management Commands ---
+    cli = cli.command('resources', 'Resources are any data that can be used in your brains, agents, and prompts. They can be text or binaries.\n', function(yargsResource) {
+        var resourcesCommand = new ResourcesCommand(server);
+        yargsResource.command('list', 'List all resources in the active project\n', function(yargsListCmd) {
+            return yargsListCmd.example('$0 resources list', 'List all resources in the active project');
+        }, function() {
+            var element = resourcesCommand.list();
+            render(element);
+        });
+        // Command available ONLY in Local Dev Mode
+        yargsResource.command('sync', 'Sync local resources folder with the server so they are available to brains when they run\n', function(yargsSyncCmd) {
+            return yargsSyncCmd.example('$0 resources sync', 'Upload new or modified resources to the server');
+        }, function() {
+            var element = resourcesCommand.sync();
+            render(element);
+        });
+        yargsResource.command('types', 'Generate TypeScript type definitions for resources\n', function(yargsTypesCmd) {
+            return yargsTypesCmd.example('$0 resources types', 'Generate a resources.d.ts file with type definitions for all resources');
+        }, function() {
+            var element = resourcesCommand.types();
+            render(element);
+        });
+        yargsResource.command('clear', 'Delete ALL resources from the server (development only)\n', function(yargsClearCmd) {
+            return yargsClearCmd.example('$0 resources clear', 'Delete all resources from the server');
+        }, function() {
+            return _async_to_generator(function() {
+                var element;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                resourcesCommand.clear()
+                            ];
+                        case 1:
+                            element = _state.sent();
+                            if (element) {
+                                render(element);
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        // Upload/delete command available in both dev and production modes
+        yargsResource.command('upload <file>', 'Upload a file as a resource, or delete with -d flag\n', function(yargsUploadCmd) {
+            return yargsUploadCmd.positional('file', {
+                describe: 'File path to upload, or resource key when using -d flag',
+                type: 'string',
+                demandOption: true
+            }).option('key', {
+                describe: 'Custom key/path for the resource (defaults to filename)',
+                type: 'string',
+                alias: 'k'
+            }).option('delete', {
+                describe: 'Delete the resource instead of uploading',
+                type: 'boolean',
+                alias: 'd',
+                default: false
+            }).option('force', {
+                describe: 'Skip confirmation prompts (use with --delete)',
+                type: 'boolean',
+                alias: 'f',
+                default: false
+            }).example('$0 resources upload video.mp4', 'Upload a video file').example('$0 resources upload /path/to/large-file.zip --key archive/backup.zip', 'Upload with custom resource key').example('$0 resources upload -d video.mp4', 'Delete the resource with key "video.mp4"').example('$0 resources upload -d archive/backup.zip', 'Delete a resource with a nested key').example('$0 resources upload -d -f video.mp4', 'Delete a resource without confirmation');
+        }, function(argv) {
+            if (argv.delete) {
+                var element = resourcesCommand.delete(argv.file, argv.force);
+                render(element);
+            } else {
+                var element1 = resourcesCommand.upload(argv.file, argv.key);
+                render(element1);
+            }
+        });
+        return yargsResource.demandCommand(1, 'You need to specify a resources command');
+    });
+    // --- Schedule Management Commands ---
+    cli = cli.command('schedule', 'Schedule brain runs to execute automatically on a cron schedule\n', function(yargsSchedule) {
+        // Add top-level options for list and delete
+        yargsSchedule.option('list', {
+            describe: 'List all scheduled brain runs',
+            type: 'boolean',
+            alias: 'l'
+        }).option('delete', {
+            describe: 'Delete a schedule by ID',
+            type: 'string',
+            alias: 'd'
+        }).option('brain', {
+            describe: 'Filter schedules by brain name (used with -l)',
+            type: 'string',
+            alias: 'b'
+        }).option('force', {
+            describe: 'Skip confirmation prompt (used with -d)',
+            type: 'boolean',
+            alias: 'f',
+            default: false
+        }).example('$0 schedule -l', 'List all schedules').example('$0 schedule -l --brain my-brain', 'List schedules for a specific brain').example('$0 schedule -d abc123', 'Delete schedule with ID abc123').example('$0 schedule -d abc123 --force', 'Delete without confirmation').check(function(argv) {
+            // Count how many operations are specified
+            var operations = [
+                argv.list,
+                argv.delete,
+                argv._.includes('create') || argv._.includes('c'),
+                argv._.includes('runs')
+            ].filter(Boolean).length;
+            if (operations === 0) {
+                throw new Error('You must specify an operation: create, -l (list), -d (delete), or runs');
+            }
+            if (operations > 1) {
+                throw new Error('You can only specify one operation at a time');
+            }
+            return true;
+        });
+        // Handle top-level list/delete options
+        yargsSchedule.middleware(function(argv) {
+            // If -l flag is used, call list command
+            if (argv.list) {
+                var element = scheduleCommand.list({
+                    brain: argv.brain
+                });
+                render(element);
+                // Exit after completion to prevent further command processing
+                process.exit(0);
+            }
+            // If -d flag is used, call delete command
+            if (argv.delete) {
+                var element1 = scheduleCommand.delete({
+                    scheduleId: argv.delete,
+                    force: argv.force
+                });
+                render(element1);
+                // Exit after completion to prevent further command processing
+                process.exit(0);
+            }
+        }, true);
+        yargsSchedule.command([
+            'create <brain-name> <cron-expression>',
+            'c <brain-name> <cron-expression>'
+        ], 'Create a new schedule for a brain\n', function(yargsCreate) {
+            return yargsCreate.positional('brain-name', {
+                describe: 'Name of the brain to schedule',
+                type: 'string',
+                demandOption: true
+            }).positional('cron-expression', {
+                describe: 'Cron expression for the schedule (e.g., "0 3 * * *" for daily at 3am)',
+                type: 'string',
+                demandOption: true
+            }).example('$0 schedule create my-brain "0 3 * * *"', 'Run my-brain daily at 3am').example('$0 schedule c my-brain "0 3 * * *"', 'Run my-brain daily at 3am (shorthand)').example('$0 schedule create data-sync "*/30 * * * *"', 'Run data-sync every 30 minutes').example('$0 schedule create weekly-report "0 9 * * 1"', 'Run weekly-report every Monday at 9am');
+        }, function(argv) {
+            var element = scheduleCommand.create(argv);
+            render(element);
+        }).command('runs', 'List scheduled run history\n', function(yargsRuns) {
+            return yargsRuns.option('schedule-id', {
+                describe: 'Filter runs by schedule ID',
+                type: 'string',
+                alias: 's'
+            }).option('limit', {
+                describe: 'Maximum number of runs to show',
+                type: 'number',
+                alias: 'n',
+                default: 20
+            }).option('status', {
+                describe: 'Filter by run status',
+                type: 'string',
+                choices: [
+                    'triggered',
+                    'failed',
+                    'complete'
+                ]
+            }).example('$0 schedule runs', 'List recent scheduled runs').example('$0 schedule runs --schedule-id abc123', 'List runs for a specific schedule').example('$0 schedule runs --status failed --limit 50', 'List last 50 failed scheduled runs');
+        }, function(argv) {
+            var element = scheduleCommand.runs(argv);
+            render(element);
+        });
+        return yargsSchedule;
+    });
+    // --- Secret Management Commands ---
+    cli = cli.command('secret', 'Manage secrets for your brains\n', function(yargsSecret) {
+        yargsSecret.command('list', 'List all secrets\n', {}, function() {
+            var element = secretCommand.list();
+            render(element);
+        }).command('create <name>', 'Create a new secret\n', function(yargsCreate) {
+            return yargsCreate.positional('name', {
+                describe: 'Name of the secret (e.g., ANTHROPIC_API_KEY)',
+                type: 'string',
+                demandOption: true
+            }).option('value', {
+                describe: 'Secret value (omit for secure input)',
+                type: 'string'
+            }).example('$0 secret create ANTHROPIC_API_KEY', 'Create a secret with secure input').example('$0 secret create DATABASE_URL --value "postgres://..."', 'Create a secret with direct value (not recommended)');
+        }, function(argv) {
+            var element = secretCommand.create(argv);
+            render(element);
+        }).command('delete <name>', 'Delete a secret\n', function(yargsDelete) {
+            return yargsDelete.positional('name', {
+                describe: 'Name of the secret to delete',
+                type: 'string',
+                demandOption: true
+            }).example('$0 secret delete ANTHROPIC_API_KEY', 'Delete a secret');
+        }, function(argv) {
+            var element = secretCommand.delete(argv);
+            render(element);
+        }).command('bulk [file]', 'Bulk upload secrets from a .env file\n', function(yargsBulk) {
+            return yargsBulk.positional('file', {
+                describe: 'Path to the .env file (defaults to .env in project root)',
+                type: 'string'
+            }).example('$0 secret bulk', 'Upload secrets from .env file in project root').example('$0 secret bulk .env.production', 'Upload secrets from a specific .env file');
+        }, function(argv) {
+            var element = secretCommand.bulk(argv);
+            render(element);
+        }).demandCommand(1, 'You need to specify a subcommand');
+        return yargsSecret;
+    });
+    cli = cli.epilogue('For more information, visit https://positronic.sh');
+    return cli;
+}