vigthoria-cli 1.12.2 → 1.13.6

package/dist/commands/chat.d.ts

@@ -1,3 +1,4 @@
+import type { Command } from 'commander';
 import { Config } from '../utils/config.js';
 import { Logger } from '../utils/logger.js';
 import { ChatMessage } from '../utils/api.js';
@@ -21,6 +22,7 @@ interface ChatOptions {
     continue?: boolean;
 }
 export declare class ChatCommand {
+    private commandProgram?;
     private config;
     private logger;
     private api;
@@ -144,7 +146,7 @@ export declare class ChatCommand {
     private writeAgentActivityLine;
     private updateV3AgentSpinner;
     private updateOperatorSpinner;
-    constructor(config: Config, logger: Logger);
+    constructor(config: Config, logger: Logger, commandProgram?: Command);
     run(options: ChatOptions): Promise<void>;
     /** Handle an inbound admin command from the Commando Bridge. */
     private handleAdminCommand;

package/dist/commands/chat.js

@@ -15,6 +15,7 @@ import { WorkspaceBrainService } from '../utils/workspace-brain-service.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session-menu.js';
 import { V4Command } from './v4.js';
+import { renderDynamicHelp } from '../utils/command-menu.js';
 import { createLiveOutcome, evaluateExecutorSuccess, handleTaskEvent, isSubstantiveAgentAnswer, isToolEvidenceStubAnswer, normalizeAgentAnswerContent, noteAnalysisToolUse, } from '../utils/agentRunOutcome.js';
 import { looksLikeMarkdownReport, renderMarkdownToTerminal, summarizeMarkdownReport, } from '../utils/terminalMarkdown.js';
 import { emitDeckEvent, isDeckModeEnabled } from '../utils/deckEvents.js';
@@ -79,6 +80,7 @@ function emitAgentJsonOutput(payload) {
     }
 }
 export class ChatCommand {
+    commandProgram;
     config;
     logger;
     api;
@@ -464,6 +466,8 @@ export class ChatCommand {
         return buildPersonaOverlay(this.getActivePersonaMode(), this.getLastUserPrompt());
     }
     isDiagnosticPrompt(prompt) {
+        if (promptRequiresWorkspaceChanges(prompt))
+            return false;
         return /(startup|start up|won'?t start|doesn'?t start|crash|crashes|error|errors|failing|fails|issue|issues|bug|bugs|diagnos|debug|runtime|log|logs|exception|traceback|stack trace|yaml|blocking|blocker)/i.test(prompt);
     }
     /**
@@ -471,6 +475,8 @@ export class ChatCommand {
      * question — these should use analysis_only workflow, not full_autonomy.
      */
     isAnalysisLookupPrompt(prompt) {
+        if (promptRequiresWorkspaceChanges(prompt))
+            return false;
         const trimmed = prompt.trim();
         if (/^(what|which|where|how many|who|find|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|count|read|look at|tell me|locate|search for|does .* exist)/i.test(trimmed)) {
             return true;
@@ -921,7 +927,13 @@ export class ChatCommand {
     }
     terminalColumns() {
         const raw = Number(process.stdout.columns || process.stderr.columns || 80);
-        return Number.isFinite(raw) && raw > 0 ? raw : 80;
+        const safe = Number.isFinite(raw) && raw > 0 ? raw : 80;
+        // process.stdout.columns is not always a reliable indicator of how many
+        // columns actually render visually (seen mismatching badly in some
+        // embedded/split-pane terminal hosts on Windows) -- cap at a
+        // conservative width so wrapped/fitted text never overflows even when
+        // the reported column count is larger than the real usable width.
+        return Math.min(safe, 60);
     }
     fitTerminalText(text, reserve = 0) {
         const width = Math.max(24, this.terminalColumns() - reserve);
@@ -1463,9 +1475,10 @@ export class ChatCommand {
             return;
         }
     }
-    constructor(config, logger) {
+    constructor(config, logger, commandProgram) {
         this.config = config;
         this.logger = logger;
+        this.commandProgram = commandProgram;
         this.api = new APIClient(config, logger);
         this.sessionManager = new SessionManager();
     }
@@ -2326,38 +2339,16 @@ export class ChatCommand {
                 : '';
             this.logger.debug(`Agent route: ${r.path} / ${r.taskKind} [${r.source}]${routerNote} — ${r.reason}`);
         }
-        const requiresV3Workflow = this.shouldRequireV3AgentWorkflow(resolvedPrompt);
-        const handledByTemplateInstant = await this.tryTemplateInstantPath(resolvedPrompt);
-        if (handledByTemplateInstant) {
-            this.saveSession();
-            return;
-        }
-        const handledByDirectFileFlow = await this.tryDirectSingleFileFlow(resolvedPrompt);
-        if (handledByDirectFileFlow) {
-            this.saveSession();
-            return;
-        }
-        // Prime the message context with the target file when the direct-file flow was
-        // bypassed (e.g. HTML files routed to V3) so the local agent loop has file
-        // awareness and the ⚙ Executing: read_file banner is always emitted.
-        await this.primeBypassedTargetFileContext(resolvedPrompt);
-        if (this.shouldPreferLocalAgentLoop(resolvedPrompt)) {
-            await this.runLocalAgentLoop(resolvedPrompt);
-            return;
-        }
         const handledByV3Workflow = await this.tryV3AgentWorkflow(resolvedPrompt);
         if (handledByV3Workflow) {
             this.saveSession();
             return;
         }
-        if (requiresV3Workflow) {
-            const errorMessage = 'This task requires the V3 agent workflow and the CLI will not fall back to the legacy local agent loop.';
-            this.logger.error(errorMessage);
-            this.messages.push({ role: 'assistant', content: errorMessage });
-            this.saveSession();
-            return;
-        }
-        await this.runLocalAgentLoop(resolvedPrompt);
+        const errorMessage = 'The V3 planner/executor workflow is unavailable. Refusing to fall back to legacy template, direct-file, or local write paths.';
+        this.logger.error(errorMessage);
+        this.messages.push({ role: 'assistant', content: errorMessage });
+        process.exitCode = 1;
+        this.saveSession();
     }
     resolveAgentTurnPrompt(prompt) {
         if (isBuiltContinuePrompt(prompt) || isBuiltRetryPrompt(prompt) || isBuiltWriteConfirmationPrompt(prompt)) {
@@ -3956,20 +3947,29 @@ export class ChatCommand {
     }
     showHelp() {
         console.log('');
-        console.log('Commands:');
-        console.log('  /help          Show this help');
-        console.log('  /exit          Exit chat');
-        console.log('  /agent         Toggle agent mode');
-        console.log('  /operator      Toggle BMAD operator mode');
-        console.log('  /context       Show current session and project memory');
-        console.log('  /memory        Show Vigthoria project brain status');
-        console.log('  /compact       Compact current session into memory summary');
-        console.log('  /clear         Clear conversation');
-        console.log('  /save          Save session');
-        console.log('  /model <name>  Change model');
-        console.log('  /status        Show the last agent run outcome');
-        console.log('  /retry         Re-run the last failed agent task');
-        console.log('  /continue      Ask the agent to keep working on unfinished tasks');
+        console.log('Interactive chat commands:');
+        const chatCommands = [
+            ['/help', 'Show this dynamically generated help'],
+            ['/exit, /quit', 'Exit chat'],
+            ['/agent', 'Toggle Agent Mode'],
+            ['/operator', 'Toggle BMAD operator mode'],
+            ['/context', 'Show current session and project memory'],
+            ['/memory', 'Show Vigthoria project brain status'],
+            ['/compact', 'Compact current session into memory summary'],
+            ['/clear', 'Clear conversation'],
+            ['/save', 'Save session'],
+            ['/model <name>', 'Change model'],
+            ['/status', 'Show the last agent run outcome'],
+            ['/retry', 'Re-run the last failed agent task'],
+            ['/continue', 'Ask the agent to keep working on unfinished tasks'],
+        ];
+        for (const [command, description] of chatCommands) {
+            console.log(`  ${command.padEnd(18)} ${description}`);
+        }
+        if (this.commandProgram) {
+            console.log('');
+            console.log(renderDynamicHelp(this.commandProgram));
+        }
         console.log('');
     }
     /**

package/dist/commands/game.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '../utils/logger.js';
+type Manager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+type CommonOptions = {
+    project?: string;
+    packageManager?: Manager;
+};
+export declare class GameCommand {
+    private logger;
+    constructor(logger: Logger);
+    init(input: string | undefined, o: {
+        engine?: string;
+        install?: boolean;
+        packageManager?: Manager;
+    }): Promise<void>;
+    run(o: CommonOptions & {
+        port?: number;
+        open?: boolean;
+    }): Promise<void>;
+    validate(o: CommonOptions & {
+        json?: boolean;
+    }): Promise<boolean>;
+    private project;
+    private sources;
+    private finish;
+}
+export {};

package/dist/commands/game.js

@@ -0,0 +1,113 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import inquirer from 'inquirer';
+import { runPostWriteValidation } from '../utils/post-write-validator.js';
+const NAME = /^[a-zA-Z0-9][a-zA-Z0-9 _-]{0,63}$/;
+const manager = (root, requested) => {
+    if (requested)
+        return requested;
+    try {
+        const value = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).packageManager?.split('@')[0];
+        if (['npm', 'pnpm', 'yarn', 'bun'].includes(value))
+            return value;
+    }
+    catch { }
+    if (fs.existsSync(path.join(root, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(root, 'yarn.lock')))
+        return 'yarn';
+    if (fs.existsSync(path.join(root, 'bun.lock')) || fs.existsSync(path.join(root, 'bun.lockb')))
+        return 'bun';
+    return 'npm';
+};
+const run = (pm, args, cwd) => new Promise((resolve, reject) => { const child = spawn(process.platform === 'win32' ? `${pm}.cmd` : pm, args, { cwd, stdio: 'inherit', windowsHide: true }); child.once('error', reject); child.once('exit', (code, signal) => code === 0 ? resolve() : reject(new Error(`${pm} exited with ${signal || code}`))); });
+const html = `<!doctype html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>VGE Game</title></head><body><canvas id="game"></canvas><div id="hud"><strong>Vigthoria Gaming Engine</strong><span>Ready</span></div><script type="module" src="/src/main.ts"></script></body></html>\n`;
+const style = `*{box-sizing:border-box}html,body,#game{width:100%;height:100%;margin:0;overflow:hidden}body{background:#030510;color:#e8f7ff;font-family:Inter,system-ui,sans-serif}#game{display:block;touch-action:none}#hud{position:fixed;left:24px;top:24px;display:flex;gap:16px;padding:12px 16px;border:1px solid #00d4ff66;border-radius:12px;background:#070a18cc;backdrop-filter:blur(12px);box-shadow:0 0 32px #7c3aed33}#hud span{color:#5eead4}\n`;
+const main = `import { ArcRotateCamera, Color3, Color4, DirectionalLight, Engine, HemisphericLight, MeshBuilder, PBRMaterial, Scene, ShadowGenerator, Vector3 } from '@babylonjs/core';
+import '@babylonjs/loaders'; import './style.css';
+const canvas=document.querySelector<HTMLCanvasElement>('#game')!; const engine=new Engine(canvas,true,{stencil:true}); const scene=new Scene(engine); scene.clearColor=new Color4(.012,.018,.05,1);
+const camera=new ArcRotateCamera('camera',-Math.PI/2,Math.PI/3,12,new Vector3(0,1,0),scene); camera.attachControl(canvas,true); new HemisphericLight('sky',new Vector3(0,1,0),scene).intensity=.55;
+const sun=new DirectionalLight('sun',new Vector3(-.5,-1,-.4),scene); sun.position=new Vector3(8,14,8); sun.intensity=2; const shadows=new ShadowGenerator(2048,sun); shadows.useBlurExponentialShadowMap=true;
+const ground=MeshBuilder.CreateGround('ground',{width:30,height:30},scene); const gm=new PBRMaterial('ground-pbr',scene); gm.albedoColor=new Color3(.025,.06,.12); gm.metallic=.35; gm.roughness=.72; ground.material=gm; ground.receiveShadows=true;
+const hero=MeshBuilder.CreateCapsule('hero',{height:2.4,radius:.55,tessellation:32},scene); hero.position.y=1.2; const hm=new PBRMaterial('hero-pbr',scene); hm.albedoColor=Color3.FromHexString('#7c3aed'); hm.metallic=.55; hm.roughness=.22; hero.material=hm; shadows.addShadowCaster(hero);
+declare global { interface Window { __vgeDiagnostics: Record<string,unknown> } }
+engine.runRenderLoop(()=>{hero.rotation.y+=engine.getDeltaTime()*.00035; scene.render(); window.__vgeDiagnostics={engineReady:true,sceneReady:true,activeCamera:camera.name,fps:Math.round(engine.getFps()),frameCount:Number(window.__vgeDiagnostics?.frameCount||0)+1,meshCount:scene.meshes.length,materialCount:scene.materials.length,assetErrors:[],consoleErrors:[]};}); addEventListener('resize',()=>engine.resize());\n`;
+export class GameCommand {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async init(input, o) {
+        if (String(o.engine || 'babylon').toLowerCase() !== 'babylon')
+            throw new Error('Unsupported engine. Use babylon.');
+        let name = input?.trim();
+        if (!name)
+            name = (await inquirer.prompt([{ type: 'input', name: 'name', message: 'Game name:', validate: v => NAME.test(String(v).trim()) || 'Use 1-64 letters, numbers, spaces, dashes, or underscores.' }])).name.trim();
+        if (!NAME.test(name))
+            throw new Error('Invalid game name.');
+        const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+        const root = path.resolve(process.cwd(), slug);
+        if (fs.existsSync(root) && fs.readdirSync(root).length)
+            throw new Error(`Target directory is not empty: ${root}`);
+        fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+        const pkg = { name: slug, version: '0.1.0', private: true, type: 'module', vigthoria: { kind: 'game', engine: 'babylon', renderTransport: 'client-state', schemaVersion: 1 }, scripts: { dev: 'vite', build: 'tsc --noEmit && vite build', preview: 'vite preview' }, dependencies: { '@babylonjs/core': '7.54.3', '@babylonjs/loaders': '7.54.3' }, devDependencies: { typescript: '5.8.3', vite: '6.1.0' } };
+        fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+        fs.writeFileSync(path.join(root, 'index.html'), html);
+        fs.writeFileSync(path.join(root, 'src/main.ts'), main);
+        fs.writeFileSync(path.join(root, 'src/style.css'), style);
+        fs.writeFileSync(path.join(root, '.gitignore'), 'node_modules\ndist\n.vigthoria\n');
+        fs.writeFileSync(path.join(root, 'tsconfig.json'), JSON.stringify({ compilerOptions: { target: 'ES2022', module: 'ESNext', lib: ['ES2022', 'DOM'], skipLibCheck: true, moduleResolution: 'Bundler', isolatedModules: true, noEmit: true, strict: true }, include: ['src'] }, null, 2) + '\n');
+        if (o.install !== false)
+            await run(manager(root, o.packageManager), ['install'], root);
+        this.logger.success(`Babylon/VGE game created: ${root}`);
+        this.logger.info(`Next: cd ${slug} && vigthoria game run`);
+    }
+    async run(o) { const root = path.resolve(o.project || process.cwd()); this.project(root); const args = ['run', 'dev', '--', '--host', '127.0.0.1']; if (o.port)
+        args.push('--port', String(o.port)); if (o.open !== false)
+        args.push('--open'); await run(manager(root, o.packageManager), args, root); }
+    async validate(o) {
+        const root = path.resolve(o.project || process.cwd());
+        const checks = [];
+        let pkg;
+        try {
+            pkg = this.project(root);
+            checks.push({ check: 'package.json', passed: true });
+        }
+        catch (e) {
+            checks.push({ check: 'package.json', passed: false, detail: e.message });
+            return this.finish(checks, o.json);
+        }
+        const source = this.sources(root);
+        checks.push({ check: 'Babylon client-state metadata', passed: pkg.vigthoria?.engine === 'babylon' && pkg.vigthoria?.renderTransport === 'client-state' }, { check: 'Pinned local Babylon dependencies', passed: /^\d/.test(pkg.dependencies?.['@babylonjs/core'] || '') && /^\d/.test(pkg.dependencies?.['@babylonjs/loaders'] || '') }, { check: 'No CDN engine imports', passed: !/https?:\/\/(cdn|unpkg|jsdelivr)[^\s"']*(babylon|three)/i.test(source) }, { check: 'Runtime diagnostics', passed: source.includes('__vgeDiagnostics') }, { check: 'Client source entry', passed: fs.existsSync(path.join(root, 'src/main.ts')) || fs.existsSync(path.join(root, 'src/main.js')) });
+        try {
+            await run(manager(root, o.packageManager), ['run', 'build'], root);
+            checks.push({ check: 'Production build', passed: true });
+        }
+        catch (e) {
+            checks.push({ check: 'Production build', passed: false, detail: e.message });
+        }
+        for (const result of await runPostWriteValidation(root))
+            checks.push({ check: result.tool, passed: result.passed, detail: result.output || undefined });
+        return this.finish(checks, o.json);
+    }
+    project(root) { if (!fs.existsSync(root) || !fs.statSync(root).isDirectory())
+        throw new Error(`Project directory not found: ${root}`); const file = path.join(root, 'package.json'); if (!fs.existsSync(file))
+        throw new Error('package.json not found'); const pkg = JSON.parse(fs.readFileSync(file, 'utf8')); if (!pkg.scripts?.dev || !pkg.scripts?.build)
+        throw new Error('Game requires dev and build scripts'); return pkg; }
+    sources(root) { const files = []; const walk = (d) => { for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+        if (['node_modules', 'dist', '.git'].includes(e.name))
+            continue;
+        const f = path.join(d, e.name);
+        if (e.isDirectory())
+            walk(f);
+        else if (/\.(html|[cm]?[jt]sx?)$/.test(e.name))
+            files.push(f);
+    } }; walk(root); return files.map(f => fs.readFileSync(f, 'utf8')).join('\n'); }
+    finish(checks, json = false) { const passed = checks.every(x => x.passed); if (json)
+        console.log(JSON.stringify({ passed, checks }, null, 2));
+    else
+        for (const c of checks)
+            (c.passed ? this.logger.success.bind(this.logger) : this.logger.error.bind(this.logger))(`${c.check}${c.detail ? `: ${c.detail.trim().slice(0, 500)}` : ''}`); if (!passed)
+        process.exitCode = 1; return passed; }
+}

package/dist/commands/repo.d.ts

@@ -1,7 +1,7 @@
 /**
  * Vigthoria CLI - Repo Commands
  *
- * Push and pull projects to/from Vigthoria Repository
+ * Push and pull projects to/from Vigthoria Community Repository
  * Enables version control and project sharing through the Vigthoria platform
  *
  * Usage:
@@ -21,6 +21,7 @@ interface PushOptions {
     description?: string;
     force?: boolean;
     yes?: boolean;
+    retry?: string;
 }
 interface PullOptions {
     output?: string;
@@ -47,6 +48,7 @@ export declare class RepoCommand {
     private getMyRepos;
     private resolveRepoByName;
     private formatRepoError;
+    private printSecurityReview;
     private isAuthenticated;
     private requireAuth;
     /**
@@ -61,6 +63,12 @@ export declare class RepoCommand {
      * Push a project to Vigthoria Repository
      */
     push(options?: PushOptions): Promise<void>;
+    /**
+     * Show the current user's repository security review queue or one review.
+     */
+    review(reviewId?: string, options?: {
+        json?: boolean;
+    }): Promise<void>;
     /**
      * Pull a project from Vigthoria Repository
      */