vigthoria-cli 1.9.2 → 1.9.5

package/dist/commands/chat.d.ts

@@ -90,6 +90,9 @@ export declare class ChatCommand {
      */
     private sanitizeServerPath;
     private describeV3AgentTool;
+    private isRawV3StreamPayload;
+    private consumeV3StreamPayload;
+    private writeV3StreamText;
     private updateV3AgentSpinner;
     private updateOperatorSpinner;
     constructor(config: Config, logger: Logger);

package/dist/commands/chat.js

@@ -476,7 +476,67 @@ class ChatCommand {
         }
         return 'Working';
     }
+    isRawV3StreamPayload(event) {
+        if (!event) {
+            return false;
+        }
+        if (typeof event === 'string' || Buffer.isBuffer(event) || event instanceof Uint8Array) {
+            return true;
+        }
+        const body = event?.body ?? event?.stream ?? event?.response;
+        return Boolean(body && (typeof body[Symbol.asyncIterator] === 'function' || typeof body.getReader === 'function'));
+    }
+    async consumeV3StreamPayload(spinner, event) {
+        try {
+            const source = (event && typeof event === 'object' && !Buffer.isBuffer(event) && !(event instanceof Uint8Array))
+                ? (event.body ?? event.stream ?? event.response ?? event)
+                : event;
+            for await (const chunk of (0, tools_js_1.robustifyStreamResponse)(source)) {
+                this.v3LastActivity = Date.now();
+                if (chunk.type === 'error') {
+                    if (spinner.isSpinning)
+                        spinner.stop();
+                    process.stderr.write(chalk_1.default.red(`\nStream error: ${chunk.content}\n`));
+                    continue;
+                }
+                if (chunk.content) {
+                    this.writeV3StreamText(spinner, chunk.content);
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (spinner.isSpinning)
+                spinner.stop();
+            process.stderr.write(chalk_1.default.red(`\nStream error: ${message}\n`));
+        }
+    }
+    writeV3StreamText(spinner, text) {
+        if (!text) {
+            return;
+        }
+        if (!this.v3StreamingStarted) {
+            this.v3StreamingStarted = true;
+            spinner.stop();
+            if (!this.directPromptMode) {
+                console.log();
+            }
+        }
+        else {
+            spinner.stop();
+        }
+        process.stdout.write(text);
+    }
     updateV3AgentSpinner(spinner, event) {
+        if (this.isRawV3StreamPayload(event)) {
+            this.consumeV3StreamPayload(spinner, event).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                if (spinner.isSpinning)
+                    spinner.stop();
+                process.stderr.write(chalk_1.default.red(`\nStream error: ${message}\n`));
+            });
+            return;
+        }
         if (!event || typeof event !== 'object') {
             return;
         }
@@ -543,17 +603,8 @@ class ChatCommand {
                 ? (event.delta?.text || '')
                 : (event.content || '');
             if (text) {
-                if (!this.v3StreamingStarted) {
-                    this.v3StreamingStarted = true;
-                    spinner.stop();
-                    if (!this.directPromptMode) {
-                        console.log();
-                    }
-                }
-                else {
-                    spinner.stop();
-                }
-                process.stdout.write(text);
+                this.v3LastActivity = Date.now();
+                this.writeV3StreamText(spinner, text);
             }
             else {
                 spinner.text = chalk_1.default.cyan('[Response] ') + 'Writing response...';
@@ -2481,10 +2532,10 @@ class ChatCommand {
     isProtectedFileReference(prompt, filePath) {
         const escapedPath = filePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const protectedPatterns = [
-            new RegExp(`do not modify\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
-            new RegExp(`don't modify\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
-            new RegExp(`leave\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?\\s+unchanged`, 'i'),
-            new RegExp(`without modifying\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
+            new RegExp(`do not modify\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
+            new RegExp(`don't modify\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
+            new RegExp(`leave\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?\\s+unchanged`, 'i'),
+            new RegExp(`without modifying\\s+[-\u001f\s\-\"][` + "'" + `]?${escapedPath}[` + "'" + `]?`, 'i'),
         ];
         return protectedPatterns.some((pattern) => pattern.test(prompt));
     }

package/dist/commands/index.js

@@ -71,7 +71,7 @@ function registerVersionInfoCommand(program) {
 const commandRegistry = [
     {
         name: 'auth',
-        handler: auth_js_1.registerAuthCommand,
+        handler: auth_js_1.registerAuthCommands,
     },
     {
         name: 'chat',

package/dist/commands/legion.d.ts

@@ -10,19 +10,15 @@
  */
 import { Config } from '../utils/config.js';
 import { Logger } from '../utils/logger.js';
-interface LegionOptions {
-    workers?: boolean;
-    status?: boolean;
-    worker?: string;
-    project?: string;
-    godmode?: boolean;
-    approve?: boolean;
-    noApprove?: boolean;
-    autoCharge?: boolean;
-    planOnly?: boolean;
-    models?: string;
-    timeoutSec?: number;
-}
+export type LegionOptions = {
+    /** Enables Vigthoria Cortex maximum-intelligence execution when --cortex is supplied. */
+    cortex?: boolean;
+    /** Model tier: 'heavy' (default — strongest LLMs) or 'lite' (cost-efficient, high quality). */
+    tier?: 'heavy' | 'lite';
+    email?: string;
+    password?: string;
+    [key: string]: any;
+};
 export declare class LegionCommand {
     private config;
     private logger;
@@ -32,15 +28,20 @@ export declare class LegionCommand {
     private readJsonResponse;
     private propagateLegionApiError;
     run(request: string | undefined, options: LegionOptions): Promise<void>;
-    private runGodmode;
+    private runCortex;
+    private isCriticalRoleFailure;
+    private isOptionalRepairRoleFailure;
+    private estimateAdditionalLoopQuote;
+    private confirmAdditionalLoopCharge;
+    private runMandatoryPreflight;
     private scanProject;
     private resolveModelProfiles;
     private buildRoleQuote;
-    private buildGodmodeExplicitSteps;
+    private buildCortexExplicitSteps;
     private buildBillingQuote;
     private evaluateBillingGate;
     private parseBooleanCandidate;
-    private fetchGodmodeEntitlement;
+    private fetchCortexEntitlement;
     private isMasterAdminFree;
     private getBillingBaseUrl;
     private parseNumericCandidate;
@@ -51,18 +52,20 @@ export declare class LegionCommand {
     private collectExecutionCharge;
     private resolveBillingInsufficientFunds;
     private printBillingGateSummary;
-    private printGodmodeQuote;
+    private printCortexQuote;
     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.
+     * gateway JWT expiry killing long-running Cortex jobs.
      */
     private getLegionStreamUrl;
     private getLegionServiceKey;
     private planAndExecute;
+    private buildCortexRunReport;
+    private extractModifiedFiles;
+    private writeCortexSummaryReport;
     private formatLegionError;
     private showWorkers;
     private showStatus;
 }
-export {};