vigthoria-cli 1.11.10 → 1.11.12

package/dist/commands/chat.d.ts

@@ -48,6 +48,7 @@ export declare class ChatCommand {
     private retryPromptStreak;
     private v3SuppressThinkingStream;
     private v3StreamedAnswerBuffer;
+    private v3StreamedAnswerDisplayed;
     private v3SeenToolCalls;
     private v3SeenToolResults;
     private lastAgentRunOutcome;
@@ -123,6 +124,9 @@ export declare class ChatCommand {
     private isRawV3StreamPayload;
     private consumeV3StreamPayload;
     private writeV3StreamText;
+    private displayV3StreamedAnswer;
+    private renderAgentAnswerForTerminal;
+    private getTerminalContentWidth;
     private sanitizeV3VisibleStreamText;
     private writeAgentActivityLine;
     private updateV3AgentSpinner;

package/dist/commands/chat.js

@@ -14,6 +14,8 @@ import { ProjectMemoryService } from '../utils/project-memory.js';
 import { buildPersonaOverlay, normalizePersonaMode } from '../utils/persona.js';
 import { runAgentSessionMenu, shouldShowAgentSessionMenu } from './agent-session-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';
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
@@ -67,6 +69,7 @@ export class ChatCommand {
     retryPromptStreak = 0;
     v3SuppressThinkingStream = false;
     v3StreamedAnswerBuffer = '';
+    v3StreamedAnswerDisplayed = false;
     v3SeenToolCalls = new Set();
     v3SeenToolResults = new Set();
     // Last completed Agent run — used by /retry, /continue, and the final summary block.
@@ -788,8 +791,37 @@ export class ChatCommand {
         else {
             spinner.stop();
         }
-        process.stdout.write(safeText);
         this.v3StreamedAnswerBuffer += safeText;
+        spinner.text = looksLikeMarkdownReport(this.v3StreamedAnswerBuffer)
+            ? 'Writing analysis report...'
+            : 'Writing response...';
+    }
+    displayV3StreamedAnswer() {
+        if (this.jsonOutput || this.v3StreamedAnswerDisplayed) {
+            return;
+        }
+        const content = this.v3StreamedAnswerBuffer.trim();
+        if (!isSubstantiveAgentAnswer(content)) {
+            return;
+        }
+        emitDeckEvent({ type: 'report_ready', markdown: content });
+        if (isDeckModeEnabled()) {
+            this.v3StreamedAnswerDisplayed = true;
+            return;
+        }
+        console.log('');
+        console.log(renderMarkdownToTerminal(content, this.getTerminalContentWidth()));
+        this.v3StreamedAnswerDisplayed = true;
+    }
+    renderAgentAnswerForTerminal(content) {
+        const normalized = String(content || '').trim();
+        if (!normalized)
+            return '';
+        return renderMarkdownToTerminal(normalized, this.getTerminalContentWidth());
+    }
+    getTerminalContentWidth() {
+        const cols = process.stdout.columns || 80;
+        return Math.max(60, Math.min(cols - 2, 100));
     }
     sanitizeV3VisibleStreamText(text) {
         let output = String(text || '');
@@ -849,6 +881,13 @@ export class ChatCommand {
             }
             this.v3SeenToolCalls.add(eventKey);
             this.v3ToolCallCount += 1;
+            const toolName = event.name || event.tool || event.tool_name || '';
+            emitDeckEvent({
+                type: 'tool_start',
+                tool: toolName,
+                index: this.v3ToolCallCount,
+                target: event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '',
+            });
             const toolDesc = this.describeV3AgentTool(event.tool || event.name || event.tool_name);
             const toolTarget = event.arguments?.path || event.arguments?.file_path || event.arguments?.pattern || '';
             const sanitizedTarget = this.sanitizeServerPath(String(toolTarget));
@@ -859,16 +898,16 @@ export class ChatCommand {
             this.writeAgentActivityLine(this.fitTerminalText(stepLabel) + '\n');
             // Show extra detail for key tools
             const args = event.arguments || {};
-            const toolName = event.name || event.tool || '';
-            if ((toolName === 'write_file' || toolName === 'edit_file') && typeof args.content === 'string') {
+            const toolNameForDetail = event.name || event.tool || '';
+            if ((toolNameForDetail === 'write_file' || toolNameForDetail === 'edit_file') && typeof args.content === 'string') {
                 const len = args.content.length;
                 this.writeAgentActivityLine(chalk.gray(`      ${len > 1000 ? Math.round(len / 1024) + ' KB' : len + ' bytes'} content\n`));
             }
-            else if (toolName === 'bash' && typeof args.command === 'string') {
+            else if (toolNameForDetail === 'bash' && typeof args.command === 'string') {
                 const command = this.sanitizeServerPath(args.command);
                 this.writeAgentActivityLine(chalk.gray(`      ${this.fitTerminalText(`$ ${command}`, 6)}\n`));
             }
-            else if (toolName === 'read_file') {
+            else if (toolNameForDetail === 'read_file') {
                 this.writeAgentActivityLine(chalk.gray(`      ${this.fitTerminalText(`reading ${sanitizedTarget || 'file'}`, 6)}\n`));
             }
             spinner.text = `Running ${toolDesc}...`;
@@ -883,6 +922,12 @@ export class ChatCommand {
                 this.v3SeenToolResults.add(eventKey);
             const success = event.success !== false;
             const toolName = event.name || event.tool || '';
+            emitDeckEvent({
+                type: 'tool_end',
+                tool: toolName,
+                success,
+                index: this.v3ToolCallCount,
+            });
             const indicator = success ? chalk.green('  ✓') : chalk.red('  ✗');
             if (spinner.isSpinning)
                 spinner.stop();
@@ -923,12 +968,15 @@ export class ChatCommand {
         if (event.type === 'thinking') {
             this.v3IterationCount += 1;
             const iterText = this.sanitizeServerPath(event.content || '');
-            if (spinner.isSpinning)
-                spinner.stop();
-            const display = iterText && !/read-only analysis turn|run at least one discovery tool/i.test(iterText)
-                ? iterText
-                : `Step ${this.v3IterationCount}: inspecting workspace…`;
-            this.writeAgentActivityLine(chalk.cyan(`\n── ${this.fitTerminalText(display, 6)} ──\n`));
+            const isGenericStep = !iterText
+                || /read-only analysis turn|run at least one discovery tool/i.test(iterText)
+                || /^Step \d+:/i.test(iterText)
+                || /reviewing attached files|inspecting workspace/i.test(iterText);
+            if (!isGenericStep) {
+                if (spinner.isSpinning)
+                    spinner.stop();
+                this.writeAgentActivityLine(chalk.cyan(`\n── ${this.fitTerminalText(iterText, 6)} ──\n`));
+            }
             spinner.text = 'Analyzing...';
             return;
         }
@@ -951,6 +999,14 @@ export class ChatCommand {
             const tools = event.tool_calls || this.v3ToolCallCount;
             if (spinner.isSpinning)
                 spinner.stop();
+            this.displayV3StreamedAnswer();
+            emitDeckEvent({
+                type: 'run_complete',
+                success: true,
+                tools: event.tool_calls || this.v3ToolCallCount,
+                iterations: event.iterations || this.v3IterationCount,
+                elapsed: event.elapsed || '',
+            });
             let statLine = `${iters} iterations, ${tools} tool calls`;
             if (elapsed)
                 statLine += `, ${elapsed}`;
@@ -2545,8 +2601,10 @@ export class ChatCommand {
         this.v3LastActivity = Date.now();
         this.v3StreamingStarted = false;
         this.v3StreamedAnswerBuffer = '';
+        this.v3StreamedAnswerDisplayed = false;
         this.v3SeenToolCalls.clear();
         this.v3SeenToolResults.clear();
+        emitDeckEvent({ type: 'agent_start' });
         const taskDisplay = new TaskDisplay(['Analyse workspace', 'Execute tasks', 'Validate output', 'Self-heal'], false);
         taskDisplay.start(0);
         const spinner = this.jsonOutput ? null : createSpinner({
@@ -2731,9 +2789,8 @@ export class ChatCommand {
             if (spinner) {
                 spinner.stop();
             }
-            // End streaming line if we streamed text inline
-            if (this.v3StreamingStarted) {
-                process.stdout.write('\n');
+            if (this.v3StreamingStarted && !this.v3StreamedAnswerDisplayed) {
+                this.displayV3StreamedAnswer();
             }
             const previewGate = (response.metadata?.previewGate || null);
             const workspaceHasOutput = this.api.hasAgentWorkspaceOutput(workspaceContext);
@@ -2828,15 +2885,13 @@ export class ChatCommand {
                 executorSucceeded = false;
             }
             if (!this.jsonOutput && !this.directPromptMode) {
-                if (this.v3StreamingStarted && isSubstantiveAgentAnswer(this.v3StreamedAnswerBuffer)) {
-                    console.log('');
-                    console.log(chalk.bold('Answer:'));
-                    console.log(this.v3StreamedAnswerBuffer.trim());
+                if (this.v3StreamedAnswerDisplayed) {
+                    // Highlighted report already printed once above.
                 }
                 else if (isSubstantiveAgentAnswer(finalAnswer)) {
                     console.log('');
                     console.log(chalk.bold('Answer:'));
-                    console.log(finalAnswer);
+                    console.log(this.renderAgentAnswerForTerminal(finalAnswer));
                 }
                 else if (!requiresWorkspaceChanges) {
                     console.log('');
@@ -2845,7 +2900,7 @@ export class ChatCommand {
                 }
                 else if (finalAnswer) {
                     console.log('');
-                    console.log(finalAnswer);
+                    console.log(this.renderAgentAnswerForTerminal(finalAnswer));
                 }
             }
             if (!executorSucceeded && requiresWorkspaceChanges && changedFileCount === 0 && !liveOutcome.executorError) {
@@ -3369,6 +3424,15 @@ export class ChatCommand {
      */
     printAgentRunSummary(outcome, evaluation, changedFileCount) {
         const executorSucceeded = evaluation.executorSucceeded;
+        if (outcome.answerContent && isSubstantiveAgentAnswer(outcome.answerContent)) {
+            const reportSummary = summarizeMarkdownReport(outcome.answerContent);
+            emitDeckEvent({
+                type: 'run_summary',
+                success: executorSucceeded,
+                title: reportSummary?.title || 'Agent run complete',
+                sections: reportSummary?.sections || [],
+            });
+        }
         const bar = chalk.gray('─'.repeat(63));
         const ok = chalk.green('✓');
         const warn = chalk.yellow('⚠');
@@ -3456,10 +3520,20 @@ export class ChatCommand {
             console.log('  ' + chalk.white(taskLine + '.'));
         }
         else if (outcome.answerContent && isSubstantiveAgentAnswer(outcome.answerContent)) {
-            const preview = outcome.answerContent.length > 160
-                ? `${outcome.answerContent.slice(0, 160)}…`
-                : outcome.answerContent;
-            console.log('  ' + chalk.white(`Answer: ${preview}`));
+            const reportSummary = summarizeMarkdownReport(outcome.answerContent);
+            if (reportSummary) {
+                const sectionPreview = reportSummary.sections.length > 0
+                    ? reportSummary.sections.slice(0, 4).join(', ')
+                    : `${Math.round(reportSummary.charCount / 1000)}k chars`;
+                console.log('  ' + chalk.white(reportSummary.title));
+                console.log('  ' + chalk.gray(`Sections: ${sectionPreview}`));
+            }
+            else {
+                const preview = outcome.answerContent.length > 160
+                    ? `${outcome.answerContent.slice(0, 160)}…`
+                    : outcome.answerContent;
+                console.log('  ' + chalk.white(preview));
+            }
         }
         else if (changedFileCount > 0) {
             console.log('  ' + chalk.white('Workspace changes were produced and are ready for review.'));

package/dist/utils/api.js

@@ -1524,7 +1524,7 @@ export class APIClient {
         if (json.length <= LIMIT)
             return json;
         if (process.env.DEBUG || process.env.VIGTHORIA_DEBUG) {
-            console.log(`[context] Payload ${json.length} chars exceeds ${LIMIT} limit, compacting...`);
+            process.stderr.write(`[context] Payload ${json.length} chars exceeds ${LIMIT} limit, compacting...\n`);
         }
         // Phase 1 — shrink workspaceFiles to fit
         const summary = payload.localWorkspaceSummary;

package/dist/utils/deckEvents.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Structured events for Vigthoria Workbench (VIGTHORIA_DECK_MODE=1).
+ * Emitted as single lines: @vigthoria-deck:{json}
+ * Workbench strips these from terminal display and updates UI panels.
+ */
+export type DeckEventType = 'agent_start' | 'tool_start' | 'tool_end' | 'report_ready' | 'run_complete' | 'run_summary';
+export interface DeckEvent {
+    type: DeckEventType;
+    ts: number;
+    [key: string]: unknown;
+}
+export declare function isDeckModeEnabled(): boolean;
+export declare function emitDeckEvent(event: Omit<DeckEvent, 'ts'> & {
+    ts?: number;
+}): void;
+export declare function parseDeckLine(line: string): DeckEvent | null;
+export declare function stripDeckLines(text: string): string;

package/dist/utils/deckEvents.js

@@ -0,0 +1,35 @@
+/**
+ * Structured events for Vigthoria Workbench (VIGTHORIA_DECK_MODE=1).
+ * Emitted as single lines: @vigthoria-deck:{json}
+ * Workbench strips these from terminal display and updates UI panels.
+ */
+const DECK_PREFIX = '@vigthoria-deck:';
+export function isDeckModeEnabled() {
+    return /^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_DECK_MODE || ''));
+}
+export function emitDeckEvent(event) {
+    if (!isDeckModeEnabled())
+        return;
+    const payload = {
+        ...event,
+        ts: event.ts ?? Date.now(),
+    };
+    process.stdout.write(`${DECK_PREFIX}${JSON.stringify(payload)}\n`);
+}
+export function parseDeckLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(DECK_PREFIX))
+        return null;
+    try {
+        return JSON.parse(trimmed.slice(DECK_PREFIX.length));
+    }
+    catch {
+        return null;
+    }
+}
+export function stripDeckLines(text) {
+    return text
+        .split('\n')
+        .filter((line) => !line.trim().startsWith(DECK_PREFIX))
+        .join('\n');
+}

package/dist/utils/terminalMarkdown.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared terminal markdown rendering for CLI commands.
+ */
+export interface MarkdownReportSummary {
+    title: string;
+    sections: string[];
+    charCount: number;
+}
+/**
+ * Clean marked-terminal output for release-grade CLI presentation.
+ */
+export declare function cleanTerminalMarkdownOutput(raw: string): string;
+export declare function looksLikeMarkdownReport(text: string): boolean;
+export declare function renderMarkdownToTerminal(markdown: string, width?: number): string;
+export declare function summarizeMarkdownReport(markdown: string): MarkdownReportSummary | null;

package/dist/utils/terminalMarkdown.js

@@ -0,0 +1,91 @@
+/**
+ * Shared terminal markdown rendering for CLI commands.
+ */
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+let cachedRenderer = null;
+function getTerminalWidth() {
+    const cols = process.stdout.columns || 80;
+    return Math.max(60, Math.min(cols - 2, 100));
+}
+function getRenderer(width) {
+    const resolvedWidth = width ?? getTerminalWidth();
+    if (cachedRenderer && cachedRenderer.width === resolvedWidth) {
+        return cachedRenderer.marked;
+    }
+    const marked = new Marked();
+    marked.use(markedTerminal({
+        showSectionPrefix: false,
+        tab: 2,
+        width: resolvedWidth,
+        reflowText: true,
+    }));
+    cachedRenderer = { width: resolvedWidth, marked };
+    return marked;
+}
+/**
+ * Clean marked-terminal output for release-grade CLI presentation.
+ */
+export function cleanTerminalMarkdownOutput(raw) {
+    let out = raw;
+    out = out.replace(/^  \* /gm, '- ');
+    out = out.replace(/^    \* /gm, '  - ');
+    const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+    out = out.split('\n').filter((line) => {
+        if (line === '')
+            return true;
+        return stripAnsi(line).trim().length > 0;
+    }).join('\n');
+    out = out.replace(/\n{3,}/g, '\n\n');
+    return out;
+}
+export function looksLikeMarkdownReport(text) {
+    const trimmed = String(text || '').trim();
+    if (!trimmed)
+        return false;
+    return /^#{1,3}\s+\S/m.test(trimmed)
+        || /^\|.+\|/m.test(trimmed)
+        || /^[-*]\s+\*\*/m.test(trimmed);
+}
+export function renderMarkdownToTerminal(markdown, width) {
+    const input = String(markdown || '').trim();
+    if (!input)
+        return '';
+    if (!looksLikeMarkdownReport(input)) {
+        return input;
+    }
+    const rendered = getRenderer(width).parse(input);
+    return cleanTerminalMarkdownOutput(rendered);
+}
+export function summarizeMarkdownReport(markdown) {
+    const text = String(markdown || '').trim();
+    if (!text || !looksLikeMarkdownReport(text)) {
+        return null;
+    }
+    const lines = text.split('\n');
+    let title = '';
+    const sections = [];
+    for (const line of lines) {
+        const h1 = line.match(/^#\s+(.+)$/);
+        if (h1 && !title) {
+            title = h1[1].replace(/[*_`]/g, '').trim();
+            continue;
+        }
+        const h2 = line.match(/^##\s+(.+)$/);
+        if (h2) {
+            const section = h2[1].replace(/[*_`]/g, '').trim();
+            if (section && sections.length < 8) {
+                sections.push(section);
+            }
+        }
+    }
+    if (!title) {
+        const firstLine = lines.find((line) => line.trim().length > 0)?.trim() || 'Analysis report';
+        title = firstLine.replace(/^#+\s*/, '').replace(/[*_`]/g, '').slice(0, 120);
+    }
+    return {
+        title,
+        sections,
+        charCount: text.length,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigthoria-cli",
-  "version": "1.11.10",
+  "version": "1.11.12",
   "description": "Vigthoria Coder CLI - AI-powered terminal coding assistant",
   "type": "module",
   "main": "dist/index.js",