@vybestack/llxprt-code 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/nonInteractiveCliSupport.ts

@@ -29,6 +29,7 @@ type StreamConsumerContext = {
   config: Config;
   jsonOutput: boolean;
   streamJsonOutput: boolean;
+  quiet: boolean;
   streamFormatter: StreamJsonFormatter | null;
   emojiFilter: EmojiFilter | undefined;
   createProfileNameWriter: () => () => void;
@@ -63,24 +64,35 @@ function emitStreamError(
   });
 }
 
+type ThoughtBufferEntry = {
+  streamId?: string;
+  text: string;
+};
+
+type ThoughtBuffer = ThoughtBufferEntry[];
+
 function flushThoughtBuffer(
-  thoughtBuffer: string,
+  thoughtBuffer: ThoughtBuffer,
   includeThinking: boolean,
-): string {
-  if (!includeThinking || !thoughtBuffer.trim()) {
-    return '';
+): ThoughtBuffer {
+  const thoughtText = thoughtBuffer
+    .map((entry) => entry.text.trim())
+    .filter(Boolean)
+    .join(' ');
+  if (!includeThinking || !thoughtText) {
+    return [];
   }
-  process.stdout.write(`<think>${thoughtBuffer.trim()}</think>\n`);
-  return '';
+  process.stdout.write(`<think>${thoughtText}</think>\n`);
+  return [];
 }
 
 function flushEmojiBuffer(
   context: StreamConsumerContext,
-  jsonResponseText: string,
+  responseText: string,
 ): string {
   const remainingBuffered = context.emojiFilter?.flushBuffer();
   if (!remainingBuffered) {
-    return jsonResponseText;
+    return responseText;
   }
   if (context.streamFormatter) {
     context.streamFormatter.emitEvent({
@@ -90,22 +102,26 @@ function flushEmojiBuffer(
       content: remainingBuffered,
       delta: true,
     });
-    return jsonResponseText;
+    return responseText;
   }
   if (context.jsonOutput) {
-    return jsonResponseText + remainingBuffered;
+    return responseText + remainingBuffered;
   }
   process.stdout.write(remainingBuffered);
-  return jsonResponseText;
+  return responseText;
 }
 
 function handleThinking(
-  thought: { subject?: string; description?: string },
+  thought: {
+    subject?: string;
+    description?: string;
+    streamId?: string;
+  },
   context: StreamConsumerContext,
   writeProfileName: () => void,
-  thoughtBuffer: string,
+  thoughtBuffer: ThoughtBuffer,
   includeThinking: boolean,
-): string {
+): ThoughtBuffer {
   if (!includeThinking) {
     return thoughtBuffer;
   }
@@ -123,14 +139,31 @@ function handleThinking(
       thoughtText = filterResult.filtered;
     }
   }
-  return thoughtBuffer ? `${thoughtBuffer} ${thoughtText}` : thoughtText;
+  if (!thoughtText.trim()) {
+    return thoughtBuffer;
+  }
+  if (thought.streamId === undefined) {
+    return [...thoughtBuffer, { text: thoughtText }];
+  }
+  const existingIndex = thoughtBuffer.findIndex(
+    (entry) => entry.streamId === thought.streamId,
+  );
+  if (existingIndex < 0) {
+    return [
+      ...thoughtBuffer,
+      { streamId: thought.streamId, text: thoughtText },
+    ];
+  }
+  return thoughtBuffer.map((entry, index) =>
+    index === existingIndex ? { ...entry, text: thoughtText } : entry,
+  );
 }
 
 function handleText(
   text: string,
   context: StreamConsumerContext,
   writeProfileName: () => void,
-  jsonResponseText: string,
+  responseText: string,
 ): string {
   writeProfileName();
   let outputValue = text;
@@ -142,7 +175,7 @@ function handleText(
           '[Error: Response blocked due to emoji detection]\n',
         );
       }
-      return jsonResponseText;
+      return responseText;
     }
     outputValue =
       typeof filterResult.filtered === 'string' ? filterResult.filtered : '';
@@ -160,13 +193,17 @@ function handleText(
         delta: true,
       });
     }
-    return jsonResponseText;
+    return responseText;
   }
   if (context.jsonOutput) {
-    return jsonResponseText + outputValue;
+    return responseText + outputValue;
   }
   process.stdout.write(outputValue);
-  return jsonResponseText;
+  return responseText;
+}
+
+function handleQuietText(text: string, state: StreamState): void {
+  state.quietTextBuffer += text;
 }
 
 function emitToolUse(
@@ -243,12 +280,20 @@ function displayToolResult(
 
 function emitFinalResult(
   context: StreamConsumerContext,
-  jsonResponseText: string,
+  responseText: string,
   startTime: number,
   metrics: SessionMetrics,
   finishReason?: 'refusal',
 ): void {
   if (context.streamFormatter) {
+    if (context.quiet) {
+      context.streamFormatter.emitEvent({
+        type: JsonStreamEventType.MESSAGE,
+        timestamp: new Date().toISOString(),
+        role: 'assistant',
+        content: responseText,
+      });
+    }
     context.streamFormatter.emitEvent({
       type: JsonStreamEventType.RESULT,
       timestamp: new Date().toISOString(),
@@ -261,7 +306,7 @@ function emitFinalResult(
   } else if (context.jsonOutput) {
     const payload: JsonOutput = {
       session_id: context.config.getSessionId(),
-      response: jsonResponseText.trimEnd(),
+      response: responseText.trimEnd(),
       stats: metrics,
     };
     if (finishReason !== undefined) {
@@ -269,7 +314,7 @@ function emitFinalResult(
     }
     process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
   } else {
-    process.stdout.write('\n');
+    process.stdout.write(`${responseText}\n`);
   }
 }
 
@@ -300,8 +345,9 @@ function reconstructError(structured: StructuredError): Error {
 function throwStructuredStreamError(
   structured: StructuredError,
   formatter: StreamJsonFormatter | null,
+  message = structured.message,
 ): never {
-  emitStreamError(formatter, 'error', structured.message, structured);
+  emitStreamError(formatter, 'error', message, structured);
   const error = reconstructError(structured);
   if (formatter !== null) {
     markMachineErrorReported(error);
@@ -312,7 +358,7 @@ function throwStructuredStreamError(
 function handleDone(
   event: Extract<AgentEvent, { type: 'done' }>,
   context: StreamConsumerContext,
-  jsonResponseText: string,
+  responseText: string,
   startTime: number,
   getMetrics: () => SessionMetrics,
 ): void {
@@ -320,7 +366,7 @@ function handleDone(
     case 'stop':
     case 'loop-detected':
     case 'context-overflow':
-      emitFinalResult(context, jsonResponseText, startTime, getMetrics());
+      emitFinalResult(context, responseText, startTime, getMetrics());
       return;
     case 'refusal': {
       // @issue:2329 — surface the safety-classifier refusal as a user-visible
@@ -333,17 +379,25 @@ function handleDone(
       // (no streamFormatter and no jsonOutput). In stream-json mode the
       // structured warning event carries the signal; in plain-JSON mode the
       // finish_reason field carries it.
-      if (!context.jsonOutput && context.streamFormatter === null) {
+      //
+      // In quiet mode all warning emissions are suppressed (issue #728).
+      if (
+        !context.quiet &&
+        !context.jsonOutput &&
+        context.streamFormatter === null
+      ) {
         process.stderr.write(`WARNING: ${REFUSAL_NOTICE_MESSAGE}\n`);
       }
-      emitStreamError(
-        context.streamFormatter,
-        'warning',
-        REFUSAL_NOTICE_MESSAGE,
-      );
+      if (!context.quiet) {
+        emitStreamError(
+          context.streamFormatter,
+          'warning',
+          REFUSAL_NOTICE_MESSAGE,
+        );
+      }
       emitFinalResult(
         context,
-        jsonResponseText,
+        responseText,
         startTime,
         getMetrics(),
         'refusal',
@@ -351,15 +405,19 @@ function handleDone(
       return;
     }
     case 'hook-stopped': {
-      const stop = event.stop;
-      const stopMessage = `Agent execution stopped: ${
-        stop?.systemMessage?.trim() ?? stop?.reason ?? ''
-      }`;
-      process.stderr.write(`${stopMessage}\n`);
+      if (!context.quiet) {
+        const stop = event.stop;
+        const stopMessage = `Agent execution stopped: ${
+          stop?.systemMessage?.trim() ?? stop?.reason ?? ''
+        }`;
+        process.stderr.write(`${stopMessage}\n`);
+      }
       return;
     }
     case 'aborted':
-      debugLogger.error('Operation cancelled.');
+      if (!context.quiet) {
+        debugLogger.error('Operation cancelled.');
+      }
       return;
     case 'max-turns':
       throw new FatalTurnLimitedError(MAX_TURNS_MESSAGE);
@@ -376,8 +434,9 @@ function handleDone(
 }
 
 function finalizeStream(
-  thoughtBuffer: string,
-  jsonResponseText: string,
+  thoughtBuffer: ThoughtBuffer,
+  responseText: string,
+  quietTextBuffer: string,
   pendingDone: Extract<AgentEvent, { type: 'done' }> | null,
   context: StreamConsumerContext,
   includeThinking: boolean,
@@ -385,7 +444,9 @@ function finalizeStream(
   getMetrics: () => SessionMetrics,
 ): void {
   flushThoughtBuffer(thoughtBuffer, includeThinking);
-  const finalText = flushEmojiBuffer(context, jsonResponseText);
+  const finalText = context.quiet
+    ? filterQuietText(quietTextBuffer, context)
+    : flushEmojiBuffer(context, responseText);
   if (pendingDone !== null) {
     handleDone(pendingDone, context, finalText, startTime, getMetrics);
   } else {
@@ -393,12 +454,56 @@ function finalizeStream(
   }
 }
 
+/**
+ * Applies the emoji filter to the fully accumulated quiet-mode text buffer.
+ * Uses filterText (not filterStreamChunk) because the buffer is complete text,
+ * not a partial streaming chunk — filterText handles full-string matching which
+ * is correct for finalized content.
+ */
+function filterQuietText(text: string, context: StreamConsumerContext): string {
+  if (!context.emojiFilter) {
+    return text;
+  }
+  const result = context.emojiFilter.filterText(text);
+  if (result.blocked) {
+    return '';
+  }
+  return typeof result.filtered === 'string' ? result.filtered : '';
+}
+
 interface StreamState {
-  thoughtBuffer: string;
-  jsonResponseText: string;
+  thoughtBuffer: ThoughtBuffer;
+  responseText: string;
+  quietTextBuffer: string;
   pendingDone: Extract<AgentEvent, { type: 'done' }> | null;
 }
 
+function handleQuietEvent(event: AgentEvent, state: StreamState): boolean {
+  switch (event.type) {
+    case 'text':
+      // Buffer text instead of writing immediately; only the final turn's
+      // text (after the last tool call) is emitted at stream completion.
+      handleQuietText(event.text, state);
+      return true;
+    case 'tool-call':
+      // Discard intermediate talk before tool calls so only the final
+      // response remains in the buffer (issue #728).
+      state.quietTextBuffer = '';
+      return true;
+    case 'tool-result':
+      // Suppress all tool result display in quiet mode.
+      return true;
+    case 'loop-detected':
+      // Suppress non-essential stream warnings/errors in quiet mode.
+      return true;
+    case 'hook-blocked':
+      // Suppress hook-blocked stderr messages in quiet mode.
+      return true;
+    default:
+      return false;
+  }
+}
+
 function dispatchAgentEvent(
   event: AgentEvent,
   state: StreamState,
@@ -406,6 +511,9 @@ function dispatchAgentEvent(
   writeProfileName: () => void,
   includeThinking: boolean,
 ): void {
+  if (context.quiet && handleQuietEvent(event, state)) {
+    return;
+  }
   switch (event.type) {
     case 'thinking':
       state.thoughtBuffer = handleThinking(
@@ -421,11 +529,11 @@ function dispatchAgentEvent(
         state.thoughtBuffer,
         includeThinking,
       );
-      state.jsonResponseText = handleText(
+      state.responseText = handleText(
         event.text,
         context,
         writeProfileName,
-        state.jsonResponseText,
+        state.responseText,
       );
       return;
     case 'tool-call':
@@ -459,7 +567,14 @@ function dispatchAgentEvent(
       return;
     }
     case 'idle-timeout':
-      return throwStructuredStreamError(event.error, context.streamFormatter);
+      if (context.quiet) {
+        throw reconstructError(event.error);
+      }
+      return throwStructuredStreamError(
+        event.error,
+        context.streamFormatter,
+        'Stream idle timeout: no response received within the allowed time.',
+      );
     case 'error':
       return throwStructuredStreamError(event.error, context.streamFormatter);
     case 'done':
@@ -487,14 +602,18 @@ export async function processAgentStream(
   startTime: number,
   getMetrics: () => SessionMetrics,
 ): Promise<void> {
-  const writeProfileName = context.createProfileNameWriter();
+  const writeProfileName = context.quiet
+    ? (): void => {}
+    : context.createProfileNameWriter();
   const includeThinking =
+    !context.quiet &&
     !context.jsonOutput &&
     !context.streamJsonOutput &&
     context.config.getEphemeralSetting('reasoning.includeInResponse') !== false;
   const state: StreamState = {
-    thoughtBuffer: '',
-    jsonResponseText: '',
+    thoughtBuffer: [],
+    responseText: '',
+    quietTextBuffer: '',
     pendingDone: null,
   };
   for await (const event of events) {
@@ -508,7 +627,8 @@ export async function processAgentStream(
   }
   finalizeStream(
     state.thoughtBuffer,
-    state.jsonResponseText,
+    state.responseText,
+    state.quietTextBuffer,
     state.pendingDone,
     context,
     includeThinking,

package/src/runtime/interactiveToolScheduler.ts

@@ -28,7 +28,7 @@ import {
   type ToolSchedulerContract,
   hasInteractiveSubagentScheduler,
   DEFAULT_AGENT_ID,
-  type AnsiOutput,
+  type LiveOutputUpdate,
   type MessageBus,
 } from '@vybestack/llxprt-code-core';
 import { DebugLogger } from '@vybestack/llxprt-code-telemetry';
@@ -149,7 +149,7 @@ export type SchedulerRefs = {
   updateToolCallOutput: (
     schedulerId: symbol,
     toolCallId: string,
-    chunk: string | AnsiOutput,
+    update: LiveOutputUpdate,
   ) => void;
   replaceToolCallsForScheduler: (
     schedulerId: symbol,
@@ -179,9 +179,9 @@ function createMainSchedulerCallbacks(
   SchedulerConfigWithExplicitMessageBus['getOrCreateScheduler']
 >[1] {
   return {
-    outputUpdateHandler: (toolCallId, chunk) => {
+    outputUpdateHandler: (toolCallId, update) => {
       if (!mounted.current) return;
-      refs.updateToolCallOutput(mainSchedulerId, toolCallId, chunk);
+      refs.updateToolCallOutput(mainSchedulerId, toolCallId, update);
       refs.setLastToolOutputTime(Date.now());
     },
     onAllToolCallsComplete: async (completedToolCalls) => {
@@ -214,8 +214,8 @@ function createSubagentCallbacks(
   SchedulerConfigWithExplicitMessageBus['getOrCreateScheduler']
 >[1] {
   return {
-    outputUpdateHandler: (toolCallId, chunk) => {
-      refs.updateToolCallOutput(schedulerId, toolCallId, chunk);
+    outputUpdateHandler: (toolCallId, update) => {
+      refs.updateToolCallOutput(schedulerId, toolCallId, update);
       refs.setLastToolOutputTime(Date.now());
     },
     onToolCallsUpdate: (calls) => {

package/src/services/BuiltinCommandLoader.ts

@@ -37,6 +37,7 @@ import { loggingCommand } from '../ui/commands/loggingCommand.js';
 import { uiprofileCommand } from '../ui/commands/uiprofileCommand.js';
 import { mouseCommand } from '../ui/commands/mouseCommand.js';
 import { quitCommand } from '../ui/commands/quitCommand.js';
+import { quotaCommand } from '../ui/commands/quotaCommand.js';
 import { restoreCommand } from '../ui/commands/restoreCommand.js';
 import { statsCommand } from '../ui/commands/statsCommand.js';
 import { themeCommand } from '../ui/commands/themeCommand.js';
@@ -154,34 +155,11 @@ export class BuiltinCommandLoader implements ICommandLoader {
       ...(isDevelopment ? [uiprofileCommand] : []),
       quitCommand,
       restoreCommand(this.config),
+      quotaCommand,
       statsCommand,
       themeCommand,
       toolsCommand,
-      // Determine skills command based on config and admin settings
-      ...((): SlashCommand[] => {
-        if (this.config?.isSkillsSupportEnabled() !== true) {
-          return [];
-        }
-        if (this.config.getSkillManager().isAdminEnabled() === false) {
-          return [
-            {
-              name: 'skills',
-              description: 'Manage skills',
-              kind: CommandKind.BUILT_IN,
-              autoExecute: false,
-              subCommands: [],
-              action: async (
-                _context: CommandContext,
-              ): Promise<MessageActionReturn> => ({
-                type: 'message',
-                messageType: 'error',
-                content: 'Skills are disabled by your admin.',
-              }),
-            },
-          ];
-        }
-        return [skillsCommand];
-      })(),
+      ...this.resolveSkillsCommand(),
       settingsCommand,
       vimCommand,
       providerCommand,
@@ -215,4 +193,34 @@ export class BuiltinCommandLoader implements ICommandLoader {
 
     return allDefinitions.filter((cmd): cmd is SlashCommand => cmd !== null);
   }
+
+  /**
+   * Determine skills command based on config and admin settings.
+   * Returns [] when skills support is disabled, a stub error command when
+   * disabled by admin, or [skillsCommand] when enabled.
+   */
+  private resolveSkillsCommand(): SlashCommand[] {
+    if (this.config?.isSkillsSupportEnabled() !== true) {
+      return [];
+    }
+    if (this.config.getSkillManager().isAdminEnabled() === false) {
+      return [
+        {
+          name: 'skills',
+          description: 'Manage skills',
+          kind: CommandKind.BUILT_IN,
+          autoExecute: false,
+          subCommands: [],
+          action: async (
+            _context: CommandContext,
+          ): Promise<MessageActionReturn> => ({
+            type: 'message',
+            messageType: 'error',
+            content: 'Skills are disabled by your admin.',
+          }),
+        },
+      ];
+    }
+    return [skillsCommand];
+  }
 }

package/src/services/FileCommandLoader.ts

@@ -9,7 +9,6 @@ import path from 'path';
 import toml from '@iarna/toml';
 import { glob } from 'glob';
 import { z } from 'zod';
-import type { CliUiRuntime } from '../ui/cliUiRuntime.js';
 import { Storage } from '@vybestack/llxprt-code-settings';
 import { debugLogger } from '@vybestack/llxprt-code-telemetry';
 import type { ICommandLoader } from './types.js';
@@ -36,6 +35,21 @@ interface CommandDirectory {
   extensionName?: string;
 }
 
+export interface FileCommandRuntime {
+  readonly storage?: Storage;
+  getProjectRoot(): string;
+  getExtensions(): Array<{
+    name: string;
+    isActive: boolean;
+    path: string;
+  }>;
+  getFolderTrust(): boolean;
+  isTrustedFolder(): boolean;
+}
+
+export const FILE_COMMANDS_UNTRUSTED_MESSAGE =
+  'File-based commands are disabled because this folder is not trusted.';
+
 /**
  * Defines the Zod schema for a command definition file. This serves as the
  * single source of truth for both validation and type inference.
@@ -60,12 +74,8 @@ const TomlCommandDefSchema = z.object({
  */
 export class FileCommandLoader implements ICommandLoader {
   private readonly projectRoot: string;
-  private readonly folderTrustEnabled: boolean;
-  private readonly isTrustedFolder: boolean;
 
-  constructor(private readonly config: CliUiRuntime | null) {
-    this.folderTrustEnabled = config?.getFolderTrust() === true;
-    this.isTrustedFolder = config?.isTrustedFolder() === true;
+  constructor(private readonly config: FileCommandRuntime | null) {
     this.projectRoot = config?.getProjectRoot() ?? process.cwd();
   }
 
@@ -81,7 +91,7 @@ export class FileCommandLoader implements ICommandLoader {
    * @returns A promise that resolves to an array of all loaded SlashCommands.
    */
   async loadCommands(signal: AbortSignal): Promise<SlashCommand[]> {
-    if (this.folderTrustEnabled && !this.isTrustedFolder) {
+    if (!this.canUseFileCommands()) {
       return [];
     }
 
@@ -131,6 +141,15 @@ export class FileCommandLoader implements ICommandLoader {
     return allCommands;
   }
 
+  private canUseFileCommands(): boolean {
+    const config = this.config;
+    return (
+      config == null ||
+      config.getFolderTrust() !== true ||
+      config.isTrustedFolder() === true
+    );
+  }
+
   /**
    * Get all command directories in order for loading.
    * User commands → Project commands → Extension commands
@@ -299,6 +318,14 @@ export class FileCommandLoader implements ICommandLoader {
       context: CommandContext,
       _args: string,
     ): Promise<SlashCommandActionReturn> => {
+      if (!this.canUseFileCommands()) {
+        return {
+          type: 'message',
+          messageType: 'error',
+          content: FILE_COMMANDS_UNTRUSTED_MESSAGE,
+        };
+      }
+
       if (!context.invocation) {
         debugLogger.error(
           `[FileCommandLoader] Critical error: Command '${baseCommandName}' was executed without invocation context.`,

package/src/test-utils/async.ts

@@ -6,6 +6,26 @@
 
 import { act } from 'react';
 
+export interface Deferred<T> {
+  readonly promise: Promise<T>;
+  readonly resolve: (value: T) => void;
+  readonly reject: (error: Error) => void;
+}
+
+export function createDeferred<T>(): Deferred<T> {
+  let resolvePromise: ((value: T) => void) | undefined;
+  let rejectPromise: ((error: Error) => void) | undefined;
+  const promise = new Promise<T>((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  return {
+    promise,
+    resolve: (value: T) => resolvePromise?.(value),
+    reject: (error: Error) => rejectPromise?.(error),
+  };
+}
+
 // The waitFor from vitest doesn't properly wrap in act(), so we have to
 // implement our own like the one in @testing-library/react
 // or @testing-library/react-native

package/src/test-utils/render.tsx

@@ -10,6 +10,7 @@ import React, { act, createContext, useContext } from 'react';
 import { LoadedSettings, type Settings } from '../config/settings.js';
 import { KeypressProvider } from '../ui/contexts/KeypressContext.js';
 import { SettingsContext } from '../ui/contexts/SettingsContext.js';
+import { ShellCommandDisplayProvider } from '../ui/contexts/ShellCommandDisplayContext.js';
 import { UIStateContext, type UIState } from '../ui/contexts/UIStateContext.js';
 import { StreamingState } from '../ui/types.js';
 
@@ -172,7 +173,15 @@ export const renderWithProviders = (
     <SettingsContext.Provider value={settings}>
       <UIStateContext.Provider value={uiState as UIState}>
         <MockRuntimeContextProvider>
-          <KeypressProvider>{component}</KeypressProvider>
+          <KeypressProvider>
+            <ShellCommandDisplayProvider
+              alwaysDisplayFullShellCommand={
+                settings.merged.ui.alwaysDisplayFullShellCommand ?? true
+              }
+            >
+              {component}
+            </ShellCommandDisplayProvider>
+          </KeypressProvider>
         </MockRuntimeContextProvider>
       </UIStateContext.Provider>
     </SettingsContext.Provider>,