vigthoria-cli 1.8.19 → 1.9.2

package/dist/commands/index.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureCommands = exports.setupCommands = void 0;
+exports.resolveCommand = resolveCommand;
+exports.registerCommands = registerCommands;
+const auth_js_1 = require("./auth.js");
+const bridge_js_1 = require("./bridge.js");
+const cancel_js_1 = require("./cancel.js");
+const chat_js_1 = require("./chat.js");
+const config_js_1 = require("./config.js");
+const deploy_js_1 = require("./deploy.js");
+const edit_js_1 = require("./edit.js");
+const explain_js_1 = require("./explain.js");
+const fork_js_1 = require("./fork.js");
+const generate_js_1 = require("./generate.js");
+const history_js_1 = require("./history.js");
+const hub_js_1 = require("./hub.js");
+const legion_js_1 = require("./legion.js");
+const preview_js_1 = require("./preview.js");
+const replay_js_1 = require("./replay.js");
+const repo_js_1 = require("./repo.js");
+const review_js_1 = require("./review.js");
+const workflow_js_1 = require("./workflow.js");
+function isRegisterableCommand(value) {
+    return Boolean(value && typeof value === 'object');
+}
+function invokeRegistrar(instance, program) {
+    if (!isRegisterableCommand(instance)) {
+        throw new Error('Command instance is not registerable');
+    }
+    const registrar = instance.register ?? instance.setup ?? instance.configure;
+    if (typeof registrar !== 'function') {
+        throw new Error('Command does not expose register(), setup(), or configure()');
+    }
+    registrar.call(instance, program);
+}
+function createClassRegistrar(CommandClass) {
+    return (program) => {
+        invokeRegistrar(new CommandClass(), program);
+    };
+}
+function registerDoctorCommand(program) {
+    program
+        .command('doctor')
+        .description('Run local Vigthoria CLI diagnostics')
+        .action(() => {
+        const checks = [
+            ['Node.js', process.version],
+            ['Platform', `${process.platform} ${process.arch}`],
+            ['Working directory', process.cwd()],
+        ];
+        console.log('Vigthoria CLI diagnostics');
+        for (const [label, value] of checks) {
+            console.log(`- ${label}: ${value}`);
+        }
+    });
+}
+function registerVersionInfoCommand(program) {
+    program
+        .command('version-info')
+        .description('Show runtime version information')
+        .action(() => {
+        console.log(JSON.stringify({
+            node: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            argv0: process.argv0,
+        }, null, 2));
+    });
+}
+const commandRegistry = [
+    {
+        name: 'auth',
+        handler: auth_js_1.registerAuthCommand,
+    },
+    {
+        name: 'chat',
+        handler: createClassRegistrar(chat_js_1.ChatCommand),
+    },
+    {
+        name: 'edit',
+        handler: createClassRegistrar(edit_js_1.EditCommand),
+    },
+    {
+        name: 'generate',
+        handler: createClassRegistrar(generate_js_1.GenerateCommand),
+    },
+    {
+        name: 'explain',
+        handler: createClassRegistrar(explain_js_1.ExplainCommand),
+    },
+    {
+        name: 'config',
+        handler: createClassRegistrar(config_js_1.ConfigCommand),
+    },
+    {
+        name: 'review',
+        handler: createClassRegistrar(review_js_1.ReviewCommand),
+    },
+    {
+        name: 'hub',
+        handler: createClassRegistrar(hub_js_1.HubCommand),
+    },
+    {
+        name: 'repo',
+        handler: createClassRegistrar(repo_js_1.RepoCommand),
+    },
+    {
+        name: 'deploy',
+        handler: createClassRegistrar(deploy_js_1.DeployCommand),
+    },
+    {
+        name: 'bridge',
+        handler: createClassRegistrar(bridge_js_1.BridgeCommand),
+    },
+    {
+        name: 'workflow',
+        handler: createClassRegistrar(workflow_js_1.WorkflowCommand),
+    },
+    {
+        name: 'preview',
+        handler: createClassRegistrar(preview_js_1.PreviewCommand),
+    },
+    {
+        name: 'legion',
+        handler: createClassRegistrar(legion_js_1.LegionCommand),
+    },
+    {
+        name: 'history',
+        handler: createClassRegistrar(history_js_1.HistoryCommand),
+    },
+    {
+        name: 'replay',
+        handler: createClassRegistrar(replay_js_1.ReplayCommand),
+    },
+    {
+        name: 'fork',
+        handler: createClassRegistrar(fork_js_1.ForkCommand),
+    },
+    {
+        name: 'cancel',
+        handler: createClassRegistrar(cancel_js_1.CancelCommand),
+    },
+    {
+        name: 'doctor',
+        handler: registerDoctorCommand,
+    },
+    {
+        name: 'version-info',
+        aliases: ['versionInfo'],
+        handler: registerVersionInfoCommand,
+    },
+];
+function normalizeCommandName(name) {
+    return name.trim().toLowerCase();
+}
+function commandNameMatches(entry, requestedName) {
+    if (normalizeCommandName(entry.name) === requestedName) {
+        return true;
+    }
+    return Boolean(entry.aliases?.some((alias) => normalizeCommandName(alias) === requestedName));
+}
+function resolveCommand(name) {
+    const requestedName = normalizeCommandName(name);
+    if (!requestedName) {
+        return null;
+    }
+    const entry = commandRegistry.find((candidate) => commandNameMatches(candidate, requestedName));
+    return entry?.handler ?? null;
+}
+function registerCommands(cli) {
+    if (!cli || typeof cli.command !== 'function') {
+        throw new Error('registerCommands requires a Commander-compatible CLI instance');
+    }
+    const program = cli;
+    for (const entry of commandRegistry) {
+        entry.handler(program);
+    }
+}
+exports.setupCommands = registerCommands;
+exports.configureCommands = registerCommands;
+exports.default = registerCommands;

package/dist/commands/legion.d.ts

@@ -15,14 +15,53 @@ interface LegionOptions {
     status?: boolean;
     worker?: string;
     project?: string;
+    godmode?: boolean;
+    approve?: boolean;
+    noApprove?: boolean;
+    autoCharge?: boolean;
+    planOnly?: boolean;
+    models?: string;
+    timeoutSec?: number;
 }
 export declare class LegionCommand {
     private config;
     private logger;
     constructor(config: Config, logger: Logger);
+    private getHyperloopUrls;
     private getHeaders;
+    private readJsonResponse;
+    private propagateLegionApiError;
     run(request: string | undefined, options: LegionOptions): Promise<void>;
+    private runGodmode;
+    private scanProject;
+    private resolveModelProfiles;
+    private buildRoleQuote;
+    private buildGodmodeExplicitSteps;
+    private buildBillingQuote;
+    private evaluateBillingGate;
+    private parseBooleanCandidate;
+    private fetchGodmodeEntitlement;
+    private isMasterAdminFree;
+    private getBillingBaseUrl;
+    private parseNumericCandidate;
+    private extractVigcoinBalance;
+    private getPurchaseUrlFromPayload;
+    private fetchWalletState;
+    private attemptDirectCharge;
+    private collectExecutionCharge;
+    private resolveBillingInsufficientFunds;
+    private printBillingGateSummary;
+    private printGodmodeQuote;
+    private confirmExecution;
+    /**
+     * SSE streaming URL for the Legion execution endpoint.
+     * Always hits Hyper Loop directly (port 8020) with the service key to avoid
+     * gateway JWT expiry killing long-running GodMode jobs.
+     */
+    private getLegionStreamUrl;
+    private getLegionServiceKey;
     private planAndExecute;
+    private formatLegionError;
     private showWorkers;
     private showStatus;
 }