test: fix nonInteractive tool output test assertions

Update test to match new tool output format that includes tool displayName and description in text mode.

packages/cli/src/nonInteractiveCli.test.ts

@@ -1826,7 +1826,7 @@ describe('runNonInteractive', () => {
     );
   });
 
-  it('should print tool output to console in text mode (non-Task tools)', async () => {
+  it('should print tool description and output to console in text mode (non-Task tools)', async () => {
     // Test that tool output is printed to stdout in text mode
     const toolCallEvent: ServerGeminiStreamEvent = {
       type: GeminiEventType.ToolCallRequest,
@@ -1839,6 +1839,21 @@ describe('runNonInteractive', () => {
       },
     };
 
+    // Mock the tool registry to return a tool with displayName and build method
+    const mockTool = {
+      displayName: 'Shell',
+      build: (args: Record<string, unknown>) => {
+        // @ts-expect-error - accessing indexed property for test mock
+        const command: string = args.command || '';
+        return {
+          getDescription: () => String(command),
+        };
+      },
+    };
+    vi.mocked(mockToolRegistry.getTool).mockReturnValue(
+      mockTool as unknown as ReturnType<typeof mockToolRegistry.getTool>,
+    );
+
     // Mock tool execution with outputUpdateHandler being called
     mockCoreExecuteToolCall.mockImplementation(
       async (_config, _request, _signal, options) => {
@@ -1901,8 +1916,15 @@ describe('runNonInteractive', () => {
     );
 
     // Verify tool output was written to stdout
-    expect(processStdoutSpy).toHaveBeenCalledWith('Package outdated\n');
-    expect(processStdoutSpy).toHaveBeenCalledWith('npm@1.0.0 -> npm@2.0.0\n');
+    // First call should be tool description
+    expect(processStdoutSpy).toHaveBeenCalledWith('Shell: npm outdated');
+    expect(processStdoutSpy).toHaveBeenCalledWith('\n');
+    // Then the actual tool output
+    expect(processStdoutSpy).toHaveBeenCalledWith('Package outdated');
+    expect(processStdoutSpy).toHaveBeenCalledWith('npm@1.0.0 -> npm@2.0.0');
+    // Final newline after tool execution
+    expect(processStdoutSpy).toHaveBeenCalledWith('\n');
+    // And the model's response
     expect(processStdoutSpy).toHaveBeenCalledWith('Dependencies checked');
   });
 });

packages/cli/src/nonInteractiveCli.ts

@@ -351,19 +351,51 @@ export async function runNonInteractive(
             const taskToolProgressHandler = taskToolProgress?.handler;
 
             // Create output handler for non-Task tools in text mode (for console output)
+            const toolOutputLines: string[] = [];
             const nonTaskOutputHandler =
               !isTaskTool && !adapter
                 ? (callId: string, outputChunk: ToolResultDisplay) => {
+                    const toolRegistry = config.getToolRegistry();
+                    const tool = toolRegistry.getTool(finalRequestInfo.name);
+                    if (tool) {
+                      try {
+                        const invocation = tool.build(finalRequestInfo.args);
+                        const description = invocation.getDescription();
+                        toolOutputLines.push(
+                          `${tool.displayName}: ${description}`,
+                        );
+                        toolOutputLines.push('\n');
+                      } catch {
+                        // If we can't build invocation, just show tool name
+                        toolOutputLines.push(`${tool.displayName}`);
+                        toolOutputLines.push('\n');
+                      }
+                    }
                     // Print tool output to console in text mode
                     if (typeof outputChunk === 'string') {
-                      process.stdout.write(outputChunk);
+                      // Indent output lines to show they're part of the tool execution
+                      const lines = outputChunk.split('\n');
+                      for (let i = 0; i < lines.length; i++) {
+                        if (i === lines.length - 1 && lines[i] === '') {
+                          // Skip trailing empty line
+                          continue;
+                        }
+                        toolOutputLines.push(lines[i]);
+                      }
                     } else if (
                       outputChunk &&
                       typeof outputChunk === 'object' &&
                       'ansiOutput' in outputChunk
                     ) {
-                      // Handle ANSI output - just print as string for now
-                      process.stdout.write(String(outputChunk.ansiOutput));
+                      // Handle ANSI output - indent it similarly
+                      const ansiStr = String(outputChunk.ansiOutput);
+                      const lines = ansiStr.split('\n');
+                      for (let i = 0; i < lines.length; i++) {
+                        if (i === lines.length - 1 && lines[i] === '') {
+                          continue;
+                        }
+                        toolOutputLines.push(lines[i]);
+                      }
                     }
                   }
                 : undefined;
@@ -386,6 +418,11 @@ export async function runNonInteractive(
                 : undefined,
             );
 
+            if (toolOutputLines.length > 0) {
+              toolOutputLines.forEach((line) => process.stdout.write(line));
+              process.stdout.write('\n');
+            }
+
             // Note: In JSON mode, subagent messages are automatically added to the main
             // adapter's messages array and will be output together on emitResult()
 

packages/vscode-ide-companion/src/open-files-manager.test.ts

@@ -6,8 +6,7 @@
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import * as vscode from 'vscode';
-import { OpenFilesManager } from './open-files-manager.js';
-import { MAX_FILES } from './services/open-files-manager/constants.js';
+import { OpenFilesManager, MAX_FILES } from './open-files-manager.js';
 
 vi.mock('vscode', () => ({
   EventEmitter: vi.fn(() => {

packages/vscode-ide-companion/src/open-files-manager.ts

@@ -9,23 +9,9 @@ import type {
   File,
   IdeContext,
 } from '@qwen-code/qwen-code-core/src/ide/types.js';
-import {
-  isFileUri,
-  isNotebookFileUri,
-  isNotebookCellUri,
-  removeFile,
-  renameFile,
-  getNotebookUriFromCellUri,
-} from './services/open-files-manager/utils.js';
-import {
-  addOrMoveToFront,
-  updateActiveContext,
-} from './services/open-files-manager/text-handler.js';
-import {
-  addOrMoveToFrontNotebook,
-  updateNotebookActiveContext,
-  updateNotebookCellSelection,
-} from './services/open-files-manager/notebook-handler.js';
+
+export const MAX_FILES = 10;
+const MAX_SELECTED_TEXT_LENGTH = 16384; // 16 KiB limit
 
 /**
  * Keeps track of the workspace state, including open files, cursor position, and selected text.
@@ -39,102 +25,33 @@ export class OpenFilesManager {
   constructor(private readonly context: vscode.ExtensionContext) {
     const editorWatcher = vscode.window.onDidChangeActiveTextEditor(
       (editor) => {
-        if (editor && isFileUri(editor.document.uri)) {
-          addOrMoveToFront(this.openFiles, editor);
+        if (editor && this.isFileUri(editor.document.uri)) {
+          this.addOrMoveToFront(editor);
           this.fireWithDebounce();
-        } else if (editor && isNotebookCellUri(editor.document.uri)) {
-          // Handle when a notebook cell becomes active (which indicates the notebook is active)
-          const notebookUri = getNotebookUriFromCellUri(editor.document.uri);
-          if (notebookUri && isNotebookFileUri(notebookUri)) {
-            // Find the notebook editor for this cell
-            const notebookEditor = vscode.window.visibleNotebookEditors.find(
-              (nbEditor) =>
-                nbEditor.notebook.uri.toString() === notebookUri.toString(),
-            );
-            if (notebookEditor) {
-              addOrMoveToFrontNotebook(this.openFiles, notebookEditor);
-              this.fireWithDebounce();
-            }
-          }
         }
       },
     );
 
-    // Watch for when notebook editors gain focus by monitoring focus changes
-    // Since VS Code doesn't have a direct onDidChangeActiveNotebookEditor event,
-    // we monitor when visible notebook editors change and assume the last one shown is active
-    let notebookFocusWatcher: vscode.Disposable | undefined;
-    if (vscode.window.onDidChangeVisibleNotebookEditors) {
-      notebookFocusWatcher = vscode.window.onDidChangeVisibleNotebookEditors(
-        () => {
-          // When visible notebook editors change, the currently focused one is likely the active one
-          const activeNotebookEditor = vscode.window.activeNotebookEditor;
-          if (
-            activeNotebookEditor &&
-            isNotebookFileUri(activeNotebookEditor.notebook.uri)
-          ) {
-            addOrMoveToFrontNotebook(this.openFiles, activeNotebookEditor);
-            this.fireWithDebounce();
-          }
-        },
-      );
-    }
-
     const selectionWatcher = vscode.window.onDidChangeTextEditorSelection(
       (event) => {
-        if (isFileUri(event.textEditor.document.uri)) {
-          updateActiveContext(this.openFiles, event.textEditor);
-          this.fireWithDebounce();
-        } else if (isNotebookCellUri(event.textEditor.document.uri)) {
-          // Handle text selections within notebook cells
-          updateNotebookCellSelection(
-            this.openFiles,
-            event.textEditor,
-            event.selections,
-          );
+        if (this.isFileUri(event.textEditor.document.uri)) {
+          this.updateActiveContext(event.textEditor);
           this.fireWithDebounce();
         }
       },
     );
 
-    // Add notebook cell selection watcher for .ipynb files if the API is available
-    let notebookCellSelectionWatcher: vscode.Disposable | undefined;
-    if (vscode.window.onDidChangeNotebookEditorSelection) {
-      notebookCellSelectionWatcher =
-        vscode.window.onDidChangeNotebookEditorSelection((event) => {
-          if (isNotebookFileUri(event.notebookEditor.notebook.uri)) {
-            // Ensure the notebook is added to the active list if selected
-            addOrMoveToFrontNotebook(this.openFiles, event.notebookEditor);
-            updateNotebookActiveContext(this.openFiles, event.notebookEditor);
-            this.fireWithDebounce();
-          }
-        });
-    }
-
     const closeWatcher = vscode.workspace.onDidCloseTextDocument((document) => {
-      if (isFileUri(document.uri)) {
-        removeFile(this.openFiles, document.uri);
+      if (this.isFileUri(document.uri)) {
+        this.remove(document.uri);
         this.fireWithDebounce();
       }
     });
 
-    // Add notebook close watcher if the API is available
-    let notebookCloseWatcher: vscode.Disposable | undefined;
-    if (vscode.workspace.onDidCloseNotebookDocument) {
-      notebookCloseWatcher = vscode.workspace.onDidCloseNotebookDocument(
-        (document) => {
-          if (isNotebookFileUri(document.uri)) {
-            removeFile(this.openFiles, document.uri);
-            this.fireWithDebounce();
-          }
-        },
-      );
-    }
-
     const deleteWatcher = vscode.workspace.onDidDeleteFiles((event) => {
       for (const uri of event.files) {
-        if (isFileUri(uri) || isNotebookFileUri(uri)) {
-          removeFile(this.openFiles, uri);
+        if (this.isFileUri(uri)) {
+          this.remove(uri);
         }
       }
       this.fireWithDebounce();
@@ -142,12 +59,12 @@ export class OpenFilesManager {
 
     const renameWatcher = vscode.workspace.onDidRenameFiles((event) => {
       for (const { oldUri, newUri } of event.files) {
-        if (isFileUri(oldUri) || isNotebookFileUri(oldUri)) {
-          if (isFileUri(newUri) || isNotebookFileUri(newUri)) {
-            renameFile(this.openFiles, oldUri, newUri);
+        if (this.isFileUri(oldUri)) {
+          if (this.isFileUri(newUri)) {
+            this.rename(oldUri, newUri);
           } else {
             // The file was renamed to a non-file URI, so we should remove it.
-            removeFile(this.openFiles, oldUri);
+            this.remove(oldUri);
           }
         }
       }
@@ -162,37 +79,87 @@ export class OpenFilesManager {
       renameWatcher,
     );
 
-    // Conditionally add notebook-specific watchers if they were created
-    if (notebookCellSelectionWatcher) {
-      context.subscriptions.push(notebookCellSelectionWatcher);
-    }
-
-    if (notebookCloseWatcher) {
-      context.subscriptions.push(notebookCloseWatcher);
-    }
-
-    if (notebookFocusWatcher) {
-      context.subscriptions.push(notebookFocusWatcher);
-    }
-
     // Just add current active file on start-up.
     if (
       vscode.window.activeTextEditor &&
-      isFileUri(vscode.window.activeTextEditor.document.uri)
+      this.isFileUri(vscode.window.activeTextEditor.document.uri)
     ) {
-      addOrMoveToFront(this.openFiles, vscode.window.activeTextEditor);
+      this.addOrMoveToFront(vscode.window.activeTextEditor);
+    }
+  }
+
+  private isFileUri(uri: vscode.Uri): boolean {
+    return uri.scheme === 'file';
+  }
+
+  private addOrMoveToFront(editor: vscode.TextEditor) {
+    // Deactivate previous active file
+    const currentActive = this.openFiles.find((f) => f.isActive);
+    if (currentActive) {
+      currentActive.isActive = false;
+      currentActive.cursor = undefined;
+      currentActive.selectedText = undefined;
     }
 
-    // Also add current active notebook if applicable and the API is available
-    if (
-      vscode.window.activeNotebookEditor &&
-      isNotebookFileUri(vscode.window.activeNotebookEditor.notebook.uri)
-    ) {
-      addOrMoveToFrontNotebook(
-        this.openFiles,
-        vscode.window.activeNotebookEditor,
-      );
+    // Remove if it exists
+    const index = this.openFiles.findIndex(
+      (f) => f.path === editor.document.uri.fsPath,
+    );
+    if (index !== -1) {
+      this.openFiles.splice(index, 1);
     }
+
+    // Add to the front as active
+    this.openFiles.unshift({
+      path: editor.document.uri.fsPath,
+      timestamp: Date.now(),
+      isActive: true,
+    });
+
+    // Enforce max length
+    if (this.openFiles.length > MAX_FILES) {
+      this.openFiles.pop();
+    }
+
+    this.updateActiveContext(editor);
+  }
+
+  private remove(uri: vscode.Uri) {
+    const index = this.openFiles.findIndex((f) => f.path === uri.fsPath);
+    if (index !== -1) {
+      this.openFiles.splice(index, 1);
+    }
+  }
+
+  private rename(oldUri: vscode.Uri, newUri: vscode.Uri) {
+    const index = this.openFiles.findIndex((f) => f.path === oldUri.fsPath);
+    if (index !== -1) {
+      this.openFiles[index].path = newUri.fsPath;
+    }
+  }
+
+  private updateActiveContext(editor: vscode.TextEditor) {
+    const file = this.openFiles.find(
+      (f) => f.path === editor.document.uri.fsPath,
+    );
+    if (!file || !file.isActive) {
+      return;
+    }
+
+    file.cursor = editor.selection.active
+      ? {
+          line: editor.selection.active.line + 1,
+          character: editor.selection.active.character,
+        }
+      : undefined;
+
+    let selectedText: string | undefined =
+      editor.document.getText(editor.selection) || undefined;
+    if (selectedText && selectedText.length > MAX_SELECTED_TEXT_LENGTH) {
+      selectedText =
+        selectedText.substring(0, MAX_SELECTED_TEXT_LENGTH) + '... [TRUNCATED]';
+    }
+    file.selectedText = selectedText;
   }
 
   private fireWithDebounce() {

packages/vscode-ide-companion/src/services/open-files-manager/constants.ts

@@ -1,8 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export const MAX_FILES = 10;
-export const MAX_SELECTED_TEXT_LENGTH = 16384; // 16 KiB limit

packages/vscode-ide-companion/src/services/open-files-manager/notebook-handler.ts

@@ -1,119 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as vscode from 'vscode';
-import type { File } from '@qwen-code/qwen-code-core/src/ide/types.js';
-import { MAX_FILES, MAX_SELECTED_TEXT_LENGTH } from './constants.js';
-import {
-  deactivateCurrentActiveFile,
-  enforceMaxFiles,
-  truncateSelectedText,
-  getNotebookUriFromCellUri,
-} from './utils.js';
-
-export function addOrMoveToFrontNotebook(
-  openFiles: File[],
-  notebookEditor: vscode.NotebookEditor,
-) {
-  // Deactivate previous active file
-  deactivateCurrentActiveFile(openFiles);
-
-  // Remove if it exists
-  const index = openFiles.findIndex(
-    (f) => f.path === notebookEditor.notebook.uri.fsPath,
-  );
-  if (index !== -1) {
-    openFiles.splice(index, 1);
-  }
-
-  // Add to the front as active
-  openFiles.unshift({
-    path: notebookEditor.notebook.uri.fsPath,
-    timestamp: Date.now(),
-    isActive: true,
-  });
-
-  // Enforce max length
-  enforceMaxFiles(openFiles, MAX_FILES);
-
-  updateNotebookActiveContext(openFiles, notebookEditor);
-}
-
-export function updateNotebookActiveContext(
-  openFiles: File[],
-  notebookEditor: vscode.NotebookEditor,
-) {
-  const file = openFiles.find(
-    (f) => f.path === notebookEditor.notebook.uri.fsPath,
-  );
-  if (!file || !file.isActive) {
-    return;
-  }
-
-  // For notebook editors, selections may span multiple cells
-  // We'll gather selected text from all selected cells
-  const selections = notebookEditor.selections;
-  let combinedSelectedText = '';
-
-  for (const selection of selections) {
-    // Process each selected cell range
-    for (let i = selection.start; i < selection.end; i++) {
-      const cell = notebookEditor.notebook.cellAt(i);
-      if (cell && cell.kind === vscode.NotebookCellKind.Code) {
-        // For now, we'll get the full cell content if it's in a selection
-        // TODO: Implement per-cell cursor position and finer-grained selection if needed
-        combinedSelectedText += cell.document.getText() + '\n';
-      }
-    }
-  }
-
-  if (combinedSelectedText) {
-    combinedSelectedText = combinedSelectedText.trim();
-    file.selectedText = truncateSelectedText(
-      combinedSelectedText,
-      MAX_SELECTED_TEXT_LENGTH,
-    );
-  } else {
-    file.selectedText = undefined;
-  }
-}
-
-export function updateNotebookCellSelection(
-  openFiles: File[],
-  cellEditor: vscode.TextEditor,
-  selections: readonly vscode.Selection[],
-) {
-  // Find the parent notebook by traversing the URI
-  const notebookUri = getNotebookUriFromCellUri(cellEditor.document.uri);
-  if (!notebookUri) {
-    return;
-  }
-
-  // Find the corresponding file entry for this notebook
-  const file = openFiles.find((f) => f.path === notebookUri.fsPath);
-  if (!file || !file.isActive) {
-    return;
-  }
-
-  // Extract the selected text from the cell editor
-  let selectedText = '';
-  for (const selection of selections) {
-    const text = cellEditor.document.getText(selection);
-    if (text) {
-      selectedText += text + '\n';
-    }
-  }
-
-  if (selectedText) {
-    selectedText = selectedText.trim();
-    file.selectedText = truncateSelectedText(
-      selectedText,
-      MAX_SELECTED_TEXT_LENGTH,
-    );
-  } else {
-    file.selectedText = undefined;
-  }
-}

packages/vscode-ide-companion/src/services/open-files-manager/text-handler.ts

@@ -1,61 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import type * as vscode from 'vscode';
-import type { File } from '@qwen-code/qwen-code-core/src/ide/types.js';
-import { MAX_FILES, MAX_SELECTED_TEXT_LENGTH } from './constants.js';
-import {
-  deactivateCurrentActiveFile,
-  enforceMaxFiles,
-  truncateSelectedText,
-} from './utils.js';
-
-export function addOrMoveToFront(openFiles: File[], editor: vscode.TextEditor) {
-  // Deactivate previous active file
-  deactivateCurrentActiveFile(openFiles);
-
-  // Remove if it exists
-  const index = openFiles.findIndex(
-    (f) => f.path === editor.document.uri.fsPath,
-  );
-  if (index !== -1) {
-    openFiles.splice(index, 1);
-  }
-
-  // Add to the front as active
-  openFiles.unshift({
-    path: editor.document.uri.fsPath,
-    timestamp: Date.now(),
-    isActive: true,
-  });
-
-  // Enforce max length
-  enforceMaxFiles(openFiles, MAX_FILES);
-
-  updateActiveContext(openFiles, editor);
-}
-
-export function updateActiveContext(
-  openFiles: File[],
-  editor: vscode.TextEditor,
-) {
-  const file = openFiles.find((f) => f.path === editor.document.uri.fsPath);
-  if (!file || !file.isActive) {
-    return;
-  }
-
-  file.cursor = editor.selection.active
-    ? {
-        line: editor.selection.active.line + 1,
-        character: editor.selection.active.character,
-      }
-    : undefined;
-
-  let selectedText: string | undefined =
-    editor.document.getText(editor.selection) || undefined;
-  selectedText = truncateSelectedText(selectedText, MAX_SELECTED_TEXT_LENGTH);
-  file.selectedText = selectedText;
-}

packages/vscode-ide-companion/src/services/open-files-manager/utils.ts

@@ -1,101 +0,0 @@
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as vscode from 'vscode';
-import type { File } from '@qwen-code/qwen-code-core/src/ide/types.js';
-
-export function isFileUri(uri: vscode.Uri): boolean {
-  return uri.scheme === 'file';
-}
-
-export function isNotebookFileUri(uri: vscode.Uri): boolean {
-  return uri.scheme === 'file' && uri.path.toLowerCase().endsWith('.ipynb');
-}
-
-export function isNotebookCellUri(uri: vscode.Uri): boolean {
-  // Notebook cell URIs have the scheme 'vscode-notebook-cell'
-  return uri.scheme === 'vscode-notebook-cell';
-}
-
-export function removeFile(openFiles: File[], uri: vscode.Uri): void {
-  const index = openFiles.findIndex((f) => f.path === uri.fsPath);
-  if (index !== -1) {
-    openFiles.splice(index, 1);
-  }
-}
-
-export function renameFile(
-  openFiles: File[],
-  oldUri: vscode.Uri,
-  newUri: vscode.Uri,
-): void {
-  const index = openFiles.findIndex((f) => f.path === oldUri.fsPath);
-  if (index !== -1) {
-    openFiles[index].path = newUri.fsPath;
-  }
-}
-
-export function deactivateCurrentActiveFile(openFiles: File[]): void {
-  const currentActive = openFiles.find((f) => f.isActive);
-  if (currentActive) {
-    currentActive.isActive = false;
-    currentActive.cursor = undefined;
-    currentActive.selectedText = undefined;
-  }
-}
-
-export function enforceMaxFiles(openFiles: File[], maxFiles: number): void {
-  if (openFiles.length > maxFiles) {
-    openFiles.pop();
-  }
-}
-
-export function truncateSelectedText(
-  selectedText: string | undefined,
-  maxLength: number,
-): string | undefined {
-  if (!selectedText) {
-    return undefined;
-  }
-  if (selectedText.length > maxLength) {
-    return selectedText.substring(0, maxLength) + '... [TRUNCATED]';
-  }
-  return selectedText;
-}
-
-export function getNotebookUriFromCellUri(
-  cellUri: vscode.Uri,
-): vscode.Uri | null {
-  // Most efficient approach: Check if the currently active notebook editor contains this cell
-  const activeNotebookEditor = vscode.window.activeNotebookEditor;
-  if (
-    activeNotebookEditor &&
-    isNotebookFileUri(activeNotebookEditor.notebook.uri)
-  ) {
-    for (let i = 0; i < activeNotebookEditor.notebook.cellCount; i++) {
-      const cell = activeNotebookEditor.notebook.cellAt(i);
-      if (cell.document.uri.toString() === cellUri.toString()) {
-        return activeNotebookEditor.notebook.uri;
-      }
-    }
-  }
-
-  // If not in the active editor, check all visible notebook editors
-  for (const editor of vscode.window.visibleNotebookEditors) {
-    if (
-      editor !== activeNotebookEditor &&
-      isNotebookFileUri(editor.notebook.uri)
-    ) {
-      for (let i = 0; i < editor.notebook.cellCount; i++) {
-        const cell = editor.notebook.cellAt(i);
-        if (cell.document.uri.toString() === cellUri.toString()) {
-          return editor.notebook.uri;
-        }
-      }
-    }
-  }
-  return null;
-}