vigthoria-cli 1.6.54 → 1.6.56

package/dist/commands/chat.js

@@ -1556,6 +1556,20 @@ class ChatCommand {
                     console.log(chalk_1.default.yellow(`Template Service preview gate: failed${previewGate.error ? ` - ${previewGate.error}` : ''}`));
                 }
             }
+            // Show change summary for files touched by the agent
+            if (!this.jsonOutput && !this.directPromptMode && response.changedFiles) {
+                const fileCount = Object.keys(response.changedFiles).length;
+                if (fileCount > 0) {
+                    console.log(chalk_1.default.gray(`\nFiles changed: ${fileCount}`));
+                    for (const relPath of Object.keys(response.changedFiles).slice(0, 15)) {
+                        console.log(chalk_1.default.gray(`  ${chalk_1.default.green('+')} ${relPath}`));
+                    }
+                    if (fileCount > 15) {
+                        console.log(chalk_1.default.gray(`  ... and ${fileCount - 15} more`));
+                    }
+                    console.log(chalk_1.default.gray(`Run ${chalk_1.default.cyan('vigthoria preview --diff')} for full visual diffs.`));
+                }
+            }
             this.messages.push({ role: 'assistant', content: response.content || 'V3 agent workflow completed.' });
             watcher?.stop();
             return true;

package/dist/commands/fork.d.ts

@@ -0,0 +1,16 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface ForkOptions {
+    eventIndex?: number;
+    project?: string;
+    json?: boolean;
+}
+export declare class ForkCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    private getBaseUrl;
+    run(runId: string, message: string, options: ForkOptions): Promise<void>;
+}
+export {};

package/dist/commands/fork.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForkCommand = void 0;
+/**
+ * fork.ts — Fork from an existing V3 agent run and stream the result.
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+class ForkCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = process.env.VIGTHORIA_TOKEN ||
+            process.env.VIGTHORIA_AUTH_TOKEN ||
+            this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY;
+        if (serviceKey)
+            headers['X-Service-Key'] = serviceKey;
+        return headers;
+    }
+    getBaseUrl() {
+        return (process.env.VIGTHORIA_V3_AGENT_URL ||
+            process.env.V3_AGENT_URL ||
+            'http://127.0.0.1:8030');
+    }
+    async run(runId, message, options) {
+        const project = options.project || process.cwd();
+        const eventIndex = options.eventIndex || 0;
+        const spinner = (0, logger_js_1.createSpinner)(`Forking run ${runId}...`).start();
+        try {
+            const baseUrl = this.getBaseUrl();
+            const body = {
+                workspace_root: project,
+                from_event_index: eventIndex,
+                new_request: message || '',
+                stream: true,
+                context: '',
+            };
+            const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/fork`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify(body),
+            });
+            if (!resp.ok) {
+                spinner.stop();
+                if (resp.status === 404) {
+                    this.logger.error(`Run ${runId} not found or has no event log.`);
+                }
+                else {
+                    this.logger.error(`Fork failed: ${resp.status} ${resp.statusText}`);
+                }
+                return;
+            }
+            spinner.stop();
+            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Forked from ${chalk_1.default.cyan(runId)} at event ${eventIndex}\n`));
+            if (!resp.body) {
+                this.logger.error('No response body');
+                return;
+            }
+            // Stream SSE events
+            const reader = resp.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let toolCallNum = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const payload = line.slice(6).trim();
+                    if (payload === '[DONE]') {
+                        console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Fork run complete\n`));
+                        return;
+                    }
+                    try {
+                        const evt = JSON.parse(payload);
+                        const type = evt.type || 'unknown';
+                        if (options.json) {
+                            console.log(JSON.stringify(evt));
+                            continue;
+                        }
+                        switch (type) {
+                            case 'context':
+                                console.log(chalk_1.default.blue(`  context: ${evt.context_id || '?'}`) +
+                                    (evt.forked_from ? chalk_1.default.dim(` (forked from ${evt.forked_from})`) : ''));
+                                break;
+                            case 'start':
+                                console.log(chalk_1.default.green(`  ▶ START`) + ` task=${evt.task_id || '?'}` +
+                                    (evt.forked_from ? chalk_1.default.dim(` forked_from=${evt.forked_from}`) : ''));
+                                break;
+                            case 'plan':
+                                console.log(chalk_1.default.magenta(`  📋 PLAN`) + ` ${evt.tasks?.length || 0} tasks`);
+                                break;
+                            case 'tool_call':
+                                toolCallNum++;
+                                console.log(chalk_1.default.yellow(`  🔧 #${toolCallNum}`) + ` ${evt.name || '?'}(${JSON.stringify(evt.arguments || {}).substring(0, 60)})`);
+                                break;
+                            case 'tool_result': {
+                                const icon = evt.success !== false ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+                                console.log(`    ${icon} ${evt.name || '?'}: ${chalk_1.default.dim((evt.output || '').substring(0, 100))}`);
+                                break;
+                            }
+                            case 'message':
+                                console.log(chalk_1.default.cyan(`  💬 `) + (evt.content || '').substring(0, 150));
+                                break;
+                            case 'complete': {
+                                const seal = evt.seal_score ? `[${evt.seal_score.tier} ${evt.seal_score.overall}]` : '';
+                                console.log(chalk_1.default.green(`  ✅ COMPLETE `) + chalk_1.default.yellow(seal) +
+                                    ` ${evt.iterations || '?'} iterations, ${evt.tool_calls || '?'} tool calls`);
+                                break;
+                            }
+                            case 'error':
+                                console.log(chalk_1.default.red(`  ❌ ERROR: `) + (evt.message || '').substring(0, 200));
+                                break;
+                            default:
+                                console.log(chalk_1.default.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
+                        }
+                    }
+                    catch {
+                        // skip unparseable lines
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spinner.stop();
+            this.logger.error(`Fork error: ${err.message}`);
+        }
+    }
+}
+exports.ForkCommand = ForkCommand;

package/dist/commands/history.d.ts

@@ -0,0 +1,16 @@
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface HistoryOptions {
+    limit?: number;
+    json?: boolean;
+    project?: string;
+}
+export declare class HistoryCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    private getBaseUrl;
+    run(options: HistoryOptions): Promise<void>;
+}
+export {};

package/dist/commands/history.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryCommand = void 0;
+/**
+ * history.ts — List recent V3 agent runs with summaries.
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+class HistoryCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = process.env.VIGTHORIA_TOKEN ||
+            process.env.VIGTHORIA_AUTH_TOKEN ||
+            this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        const serviceKey = process.env.VIGTHORIA_V3_SERVICE_KEY;
+        if (serviceKey)
+            headers['X-Service-Key'] = serviceKey;
+        return headers;
+    }
+    getBaseUrl() {
+        return (process.env.VIGTHORIA_V3_AGENT_URL ||
+            process.env.V3_AGENT_URL ||
+            'http://127.0.0.1:8030');
+    }
+    async run(options) {
+        const limit = options.limit || 20;
+        const project = options.project || process.cwd();
+        const spinner = (0, logger_js_1.createSpinner)('Loading run history...').start();
+        try {
+            const baseUrl = this.getBaseUrl();
+            const params = new URLSearchParams({
+                limit: String(limit),
+                workspace_root: project,
+            });
+            const resp = await fetch(`${baseUrl}/api/runs?${params}`, {
+                headers: this.getHeaders(),
+            });
+            if (!resp.ok) {
+                spinner.stop();
+                this.logger.error(`Failed to fetch runs: ${resp.status} ${resp.statusText}`);
+                return;
+            }
+            const data = (await resp.json());
+            spinner.stop();
+            if (options.json) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            if (data.runs.length === 0) {
+                this.logger.info(chalk_1.default.dim('No runs found.'));
+                return;
+            }
+            console.log(chalk_1.default.bold(`\n${logger_js_1.CH.success} Recent Runs (${data.count})\n`));
+            for (const run of data.runs) {
+                const tier = run.seal_score?.tier || 'unknown';
+                const tierColor = tier === 'gold' ? chalk_1.default.yellow :
+                    tier === 'silver' ? chalk_1.default.white :
+                        tier === 'bronze' ? chalk_1.default.hex('#cd7f32') :
+                            tier === 'failed' ? chalk_1.default.red :
+                                chalk_1.default.dim;
+                const score = run.seal_score?.overall != null ? `${run.seal_score.overall}` : '—';
+                const status = run.failed > 0
+                    ? chalk_1.default.red(`${run.completed}/${run.task_count} ✗`)
+                    : chalk_1.default.green(`${run.completed}/${run.task_count} ✓`);
+                console.log(`  ${chalk_1.default.cyan(run.run_id.substring(0, 16))}  ` +
+                    `${chalk_1.default.dim(run.archived_at || '?')}  ` +
+                    `${status}  ` +
+                    `${tierColor(`[${tier} ${score}]`)}  ` +
+                    `${chalk_1.default.white(run.request?.substring(0, 60) || '(no request)')}`);
+            }
+            console.log();
+        }
+        catch (err) {
+            spinner.stop();
+            this.logger.error(`History error: ${err.message}`);
+        }
+    }
+}
+exports.HistoryCommand = HistoryCommand;

package/dist/commands/legion.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Vigthoria CLI - Legion Parallel Orchestration
+ *
+ * Submit work to Hyper Loop's Legion engine for parallel execution.
+ *
+ * Usage:
+ *   vigthoria legion "Refactor auth and update tests"
+ *   vigthoria legion --workers          List available Legion workers
+ *   vigthoria legion --status           Show Legion infrastructure status
+ */
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface LegionOptions {
+    workers?: boolean;
+    status?: boolean;
+    worker?: string;
+    project?: string;
+}
+export declare class LegionCommand {
+    private config;
+    private logger;
+    constructor(config: Config, logger: Logger);
+    private getHeaders;
+    run(request: string | undefined, options: LegionOptions): Promise<void>;
+    private planAndExecute;
+    private showWorkers;
+    private showStatus;
+}
+export {};

package/dist/commands/legion.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Vigthoria CLI - Legion Parallel Orchestration
+ *
+ * Submit work to Hyper Loop's Legion engine for parallel execution.
+ *
+ * Usage:
+ *   vigthoria legion "Refactor auth and update tests"
+ *   vigthoria legion --workers          List available Legion workers
+ *   vigthoria legion --status           Show Legion infrastructure status
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegionCommand = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = require("../utils/logger.js");
+const HYPERLOOP_URLS = [
+    'http://localhost:8020/api/hyperloop',
+    'http://10.0.0.2:8020/api/hyperloop',
+];
+class LegionCommand {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    getHeaders() {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = this.config.get('authToken');
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+            headers['Cookie'] = `vigthoria-auth-token=${token}`;
+        }
+        return headers;
+    }
+    async run(request, options) {
+        if (options.workers) {
+            await this.showWorkers();
+            return;
+        }
+        if (options.status) {
+            await this.showStatus();
+            return;
+        }
+        if (!request) {
+            console.log(chalk_1.default.yellow('Usage: vigthoria legion "<task description>"'));
+            console.log(chalk_1.default.gray('  --workers     List available Legion workers'));
+            console.log(chalk_1.default.gray('  --status      Show Legion infrastructure status'));
+            return;
+        }
+        await this.planAndExecute(request, options);
+    }
+    async planAndExecute(request, options) {
+        const spinner = (0, logger_js_1.createSpinner)('Submitting to Legion parallel orchestrator...').start();
+        const body = {
+            request,
+            context: {
+                workspace: options.project || process.cwd(),
+            },
+            constraints: {},
+        };
+        for (const baseUrl of HYPERLOOP_URLS) {
+            try {
+                const response = await fetch(`${baseUrl}/legion/plan/execute`, {
+                    method: 'POST',
+                    headers: this.getHeaders(),
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(300000),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => '');
+                    throw new Error(`Legion API ${response.status}: ${errorText.slice(0, 200)}`);
+                }
+                const result = await response.json();
+                spinner.stop();
+                console.log();
+                console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Execution Report ${logger_js_1.CH.hLine.repeat(34)}`));
+                console.log();
+                if (result.status === 'success' || result.ok) {
+                    console.log(chalk_1.default.green(`  ${logger_js_1.CH.success} Legion completed successfully`));
+                }
+                else if (result.status === 'partial') {
+                    console.log(chalk_1.default.yellow(`  ${logger_js_1.CH.warn} Legion completed partially`));
+                }
+                else {
+                    console.log(chalk_1.default.red(`  ${logger_js_1.CH.error} Legion execution failed`));
+                }
+                // Show execution graph results
+                if (result.graph_results || result.results) {
+                    const results = result.graph_results || result.results || [];
+                    const steps = Array.isArray(results) ? results : (typeof results === 'object' ? Object.values(results) : []);
+                    if (steps.length > 0) {
+                        console.log();
+                        console.log(chalk_1.default.white('  Steps:'));
+                        for (const step of steps) {
+                            const stepObj = step;
+                            const icon = stepObj.status === 'completed' || stepObj.success
+                                ? chalk_1.default.green(logger_js_1.CH.success)
+                                : chalk_1.default.red(logger_js_1.CH.error);
+                            const name = stepObj.step_id || stepObj.worker || stepObj.name || 'step';
+                            const summary = stepObj.summary || stepObj.result || '';
+                            console.log(`    ${icon} ${chalk_1.default.white(String(name))}${summary ? chalk_1.default.gray(` — ${String(summary).slice(0, 100)}`) : ''}`);
+                        }
+                    }
+                }
+                // Show timing and artifacts
+                if (result.elapsed_seconds || result.elapsed) {
+                    console.log();
+                    console.log(chalk_1.default.gray(`  Time: ${(result.elapsed_seconds || result.elapsed || 0).toFixed(1)}s`));
+                }
+                if (result.content) {
+                    console.log();
+                    console.log(chalk_1.default.white(String(result.content).slice(0, 500)));
+                }
+                console.log();
+                return;
+            }
+            catch (error) {
+                if (error?.name === 'AbortError') {
+                    spinner.stop();
+                    this.logger.error('Legion request timed out');
+                    return;
+                }
+                // Try next URL
+                continue;
+            }
+        }
+        spinner.stop();
+        this.logger.error('Could not reach Hyper Loop Legion API. Is vigthoria-hyper-loop running?');
+    }
+    async showWorkers() {
+        const spinner = (0, logger_js_1.createSpinner)('Fetching Legion worker catalog...').start();
+        for (const baseUrl of HYPERLOOP_URLS) {
+            try {
+                const response = await fetch(`${baseUrl}/legion/workers`, {
+                    signal: AbortSignal.timeout(10000),
+                    headers: this.getHeaders(),
+                });
+                if (!response.ok)
+                    continue;
+                const data = await response.json();
+                spinner.stop();
+                console.log();
+                console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Worker Catalog ${logger_js_1.CH.hLine.repeat(37)}`));
+                console.log();
+                const workers = data.workers || data.catalog || data;
+                if (Array.isArray(workers)) {
+                    for (const w of workers) {
+                        const wObj = w;
+                        const statusColor = wObj.status === 'active' ? chalk_1.default.green : chalk_1.default.yellow;
+                        console.log(`  ${statusColor(logger_js_1.CH.bullet)} ${chalk_1.default.white(wObj.name || wObj.worker || 'unknown')}  ${chalk_1.default.gray(wObj.description || '')}`);
+                        if (wObj.status) {
+                            console.log(chalk_1.default.gray(`    Status: ${wObj.status}`));
+                        }
+                    }
+                }
+                else if (typeof workers === 'object') {
+                    for (const [name, info] of Object.entries(workers)) {
+                        const infoObj = info;
+                        const statusColor = infoObj.maturity === 'active' ? chalk_1.default.green : chalk_1.default.yellow;
+                        console.log(`  ${statusColor(logger_js_1.CH.bullet)} ${chalk_1.default.white(name)}  ${chalk_1.default.gray(infoObj.description || '')}`);
+                        if (infoObj.maturity)
+                            console.log(chalk_1.default.gray(`    Maturity: ${infoObj.maturity}`));
+                        if (infoObj.domains)
+                            console.log(chalk_1.default.gray(`    Domains: ${Array.isArray(infoObj.domains) ? infoObj.domains.join(', ') : infoObj.domains}`));
+                    }
+                }
+                console.log();
+                return;
+            }
+            catch {
+                continue;
+            }
+        }
+        spinner.stop();
+        this.logger.error('Could not reach Hyper Loop. Is vigthoria-hyper-loop running?');
+    }
+    async showStatus() {
+        const spinner = (0, logger_js_1.createSpinner)('Checking Legion infrastructure...').start();
+        for (const baseUrl of HYPERLOOP_URLS) {
+            try {
+                const response = await fetch(`${baseUrl}/status`, {
+                    signal: AbortSignal.timeout(10000),
+                    headers: this.getHeaders(),
+                });
+                if (!response.ok)
+                    continue;
+                const data = await response.json();
+                spinner.stop();
+                console.log();
+                console.log(chalk_1.default.bold.white(`  ${logger_js_1.CH.hLine.repeat(3)} Legion Infrastructure ${logger_js_1.CH.hLine.repeat(37)}`));
+                console.log();
+                console.log(chalk_1.default.gray(`  Hyper Loop: `) + chalk_1.default.green('online'));
+                if (data.workers || data.active_workers) {
+                    const count = data.workers || data.active_workers;
+                    console.log(chalk_1.default.gray(`  Active workers: `) + chalk_1.default.white(String(typeof count === 'number' ? count : Object.keys(count).length)));
+                }
+                if (data.remotes || data.infrastructure) {
+                    const remotes = data.remotes || data.infrastructure;
+                    if (typeof remotes === 'object') {
+                        for (const [name, status] of Object.entries(remotes)) {
+                            const icon = status?.reachable ? chalk_1.default.green(logger_js_1.CH.success) : chalk_1.default.red(logger_js_1.CH.error);
+                            console.log(`  ${icon} ${chalk_1.default.white(name)}`);
+                        }
+                    }
+                }
+                console.log();
+                return;
+            }
+            catch {
+                continue;
+            }
+        }
+        spinner.stop();
+        console.log();
+        console.log(chalk_1.default.gray('  Hyper Loop: ') + chalk_1.default.red('offline'));
+        console.log();
+    }
+}
+exports.LegionCommand = LegionCommand;

package/dist/commands/preview.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Vigthoria CLI - Preview Command
+ *
+ * Local preview server + consolidated visual diffs + Template Service proof gate
+ *
+ * Usage:
+ *   vigthoria preview                     - Preview project in browser
+ *   vigthoria preview --diff              - Show consolidated diff of recent agent changes
+ *   vigthoria preview --proof             - Run Template Service preview gate
+ *   vigthoria preview -p /path/to/project - Preview specific project
+ */
+import { Config } from '../utils/config.js';
+import { Logger } from '../utils/logger.js';
+interface PreviewOptions {
+    project: string;
+    entry?: string;
+    port?: number;
+    open?: boolean;
+    diff?: boolean;
+    proof?: boolean;
+    screenshot?: boolean;
+}
+export declare class PreviewCommand {
+    private config;
+    private logger;
+    private api;
+    private server;
+    constructor(config: Config, logger: Logger);
+    run(options: PreviewOptions): Promise<void>;
+    /**
+     * Detect the HTML entry file in the project
+     */
+    private detectEntryFile;
+    /**
+     * Find an available port starting from the given number
+     */
+    private findAvailablePort;
+    /**
+     * Start a local HTTP server for preview
+     */
+    private startServer;
+    /**
+     * Open URL in default browser
+     */
+    private openBrowser;
+    /**
+     * Show consolidated diff of recent agent changes using git
+     */
+    showConsolidatedDiff(projectPath: string): Promise<void>;
+    /**
+     * Run Template Service preview gate and persist proof bundle
+     */
+    private runProofGate;
+}
+export {};