vigthoria-cli 1.8.15 → 1.9.2

package/dist/commands/config.d.ts

@@ -16,6 +16,8 @@ export declare class ConfigCommand {
     run(options: ConfigOptions): Promise<void>;
     init(): Promise<void>;
     private setConfig;
+    private formatConfigValueForDisplay;
+    private redactConfigUrl;
     private getConfig;
     private listConfig;
     private resetConfig;

package/dist/commands/config.js

@@ -100,20 +100,14 @@ class ConfigCommand {
                 message: 'Default AI model:',
                 choices: [
                     { name: '═══ Code Models ═══', disabled: true },
-                    { name: 'Vigthoria Code V2 (8B) - Best for coding', value: 'code-v2-8b' },
-                    { name: 'Vigthoria Code V3 (8B) - Next gen coding', value: 'code-v3-8b' },
-                    { name: 'Vigthoria Code V3 (32B) - Large scale coding', value: 'code-v3-32b' },
+                    { name: 'Vigthoria v3 Code 35B - Flagship coding model', value: 'code' },
+                    { name: 'Vigthoria v3 Code 35B - Explicit 35B selection', value: 'code-35b' },
+                    { name: 'Vigthoria C1 Code 9B - Fast coding specialist', value: 'code-9b' },
                     { name: '═══ General Models ═══', disabled: true },
-                    { name: 'Vigthoria Fast (1.7B) - Quick responses', value: 'fast' },
-                    { name: 'Vigthoria Mini (0.6B) - Ultra lightweight', value: 'mini' },
-                    { name: 'Vigthoria Balanced (4B) - All-purpose', value: 'balanced' },
-                    { name: '═══ Creative Models ═══', disabled: true },
-                    { name: 'Vigthoria Creative V4 (9B) - Creative tasks', value: 'creative-v4' },
-                    { name: 'Vigthoria Creative V3 (9B) - Legacy creative', value: 'creative-v3' },
-                    { name: '═══ Specialized Models ═══', disabled: true },
-                    { name: 'Vigthoria Music Master (4B) - Music AI', value: 'music' },
+                    { name: 'Vigthoria Master 7.6B - Balanced general model', value: 'balanced' },
+                    { name: 'Vigthoria v3 Balanced 4B - Efficient general purpose', value: 'balanced-4b' },
                 ],
-                default: 'code-v2-8b',
+                default: 'code',
             },
             {
                 type: 'input',
@@ -172,13 +166,39 @@ class ConfigCommand {
         };
         if (configMap[key]) {
             configMap[key](value);
-            this.logger.success(`Set ${key} = ${value}`);
+            this.logger.success(`Set ${key} = ${this.formatConfigValueForDisplay(key, value)}`);
         }
         else {
             this.logger.error(`Unknown config key: ${key}`);
             console.log(chalk_1.default.gray('Available keys: model, theme, autoApply, showDiffs, maxTokens, apiUrl, modelsApiUrl, wsUrl, selfHostedModelsApiUrl'));
         }
     }
+    formatConfigValueForDisplay(key, value) {
+        if (key === 'apiUrl' || key === 'modelsApiUrl' || key === 'wsUrl' || key === 'selfHostedModelsApiUrl') {
+            return this.redactConfigUrl(value);
+        }
+        return value;
+    }
+    redactConfigUrl(url) {
+        const text = String(url || '').trim();
+        if (!text)
+            return text;
+        try {
+            const parsed = new URL(text);
+            const host = parsed.hostname.toLowerCase();
+            const isLocal = host === 'localhost' || host === '127.0.0.1';
+            const isPrivate = /^10\./.test(host)
+                || /^192\.168\./.test(host)
+                || /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(host);
+            if (isLocal || isPrivate) {
+                return '[redacted-host]';
+            }
+            return text;
+        }
+        catch {
+            return text.replace(/\b(?:localhost|127\.0\.0\.1)(?::\d+)?\b/gi, '[redacted-host]');
+        }
+    }
     getConfig(key) {
         const all = this.config.getAll();
         const flatConfig = {
@@ -207,9 +227,9 @@ class ConfigCommand {
         console.log(chalk_1.default.cyan('═══ Vigthoria CLI Configuration ═══'));
         console.log();
         console.log(chalk_1.default.white('API:'));
-        console.log(chalk_1.default.gray('  URL: ') + chalk_1.default.cyan(all.apiUrl));
-        console.log(chalk_1.default.gray('  Models API: ') + chalk_1.default.cyan(all.modelsApiUrl));
-        console.log(chalk_1.default.gray('  WebSocket: ') + chalk_1.default.cyan(all.wsUrl));
+        console.log(chalk_1.default.gray('  URL: ') + chalk_1.default.cyan(this.redactConfigUrl(all.apiUrl)));
+        console.log(chalk_1.default.gray('  Models API: ') + chalk_1.default.cyan(this.redactConfigUrl(all.modelsApiUrl)));
+        console.log(chalk_1.default.gray('  WebSocket: ') + chalk_1.default.cyan(this.redactConfigUrl(all.wsUrl)));
         console.log(chalk_1.default.gray('  Self-hosted Models: ') + chalk_1.default.cyan(all.selfHostedModelsApiUrl || 'disabled'));
         console.log();
         console.log(chalk_1.default.white('Preferences:'));
@@ -264,10 +284,10 @@ class ConfigCommand {
                 name: 'defaultModel',
                 message: 'Default AI model:',
                 choices: [
-                    { name: 'Vigthoria Code (8B)', value: 'vigthoria-code' },
-                    { name: 'Vigthoria Fast (1.1B)', value: 'vigthoria-fast' },
-                    { name: 'Vigthoria Mini (3.8B)', value: 'vigthoria-mini' },
-                    { name: 'Vigthoria Creative (9B)', value: 'vigthoria-creative' },
+                    { name: 'Vigthoria v3 Code 35B', value: 'code' },
+                    { name: 'Vigthoria C1 Code 9B', value: 'code-9b' },
+                    { name: 'Vigthoria Master 7.6B', value: 'balanced' },
+                    { name: 'Vigthoria v3 Balanced 4B', value: 'balanced-4b' },
                 ],
                 default: current.preferences.defaultModel,
             },

package/dist/commands/index.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+export interface CommandRegistrationResult {
+    name: string;
+    registered: boolean;
+    error?: Error;
+}
+export type CommandRegistrar = (program: Command) => void;
+export declare function resolveCommand(name: string): CommandRegistrar | null;
+export declare function registerCommands(cli: any): void;
+export declare const setupCommands: typeof registerCommands;
+export declare const configureCommands: typeof registerCommands;
+export default registerCommands;

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;
 }