snow-ai 0.4.6 → 0.4.7

package/dist/api/anthropic.js

@@ -97,13 +97,42 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
             continue;
         }
         if (msg.role === 'tool' && msg.tool_call_id) {
+            // Build tool_result content - can be text or array with images
+            let toolResultContent;
+            if (msg.images && msg.images.length > 0) {
+                // Multimodal tool result with images
+                const contentArray = [];
+                // Add text content first
+                if (msg.content) {
+                    contentArray.push({
+                        type: 'text',
+                        text: msg.content,
+                    });
+                }
+                // Add images
+                for (const image of msg.images) {
+                    contentArray.push({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: image.mimeType,
+                            data: image.data,
+                        },
+                    });
+                }
+                toolResultContent = contentArray;
+            }
+            else {
+                // Text-only tool result
+                toolResultContent = msg.content;
+            }
             anthropicMessages.push({
                 role: 'user',
                 content: [
                     {
                         type: 'tool_result',
                         tool_use_id: msg.tool_call_id,
-                        content: msg.content,
+                        content: toolResultContent,
                     },
                 ],
             });

package/dist/api/chat.js

@@ -50,6 +50,31 @@ function convertToOpenAIMessages(messages, includeBuiltinSystemPrompt = true) {
             };
         }
         if (msg.role === 'tool' && msg.tool_call_id) {
+            // Handle multimodal tool results with images
+            if (msg.images && msg.images.length > 0) {
+                const content = [];
+                // Add text content
+                if (msg.content) {
+                    content.push({
+                        type: 'text',
+                        text: msg.content,
+                    });
+                }
+                // Add images as base64 data URLs
+                for (const image of msg.images) {
+                    content.push({
+                        type: 'image_url',
+                        image_url: {
+                            url: `data:${image.mimeType};base64,${image.data}`,
+                        },
+                    });
+                }
+                return {
+                    role: 'tool',
+                    content,
+                    tool_call_id: msg.tool_call_id,
+                };
+            }
             return {
                 role: 'tool',
                 content: msg.content,

package/dist/api/gemini.js

@@ -91,6 +91,18 @@ function convertToGeminiMessages(messages, includeBuiltinSystemPrompt = true) {
             // Tool response must be a valid object for Gemini API
             // If content is a JSON string, parse it; otherwise wrap it in an object
             let responseData;
+            const imageParts = [];
+            // Handle images from tool result
+            if (msg.images && msg.images.length > 0) {
+                for (const image of msg.images) {
+                    imageParts.push({
+                        inlineData: {
+                            mimeType: image.mimeType,
+                            data: image.data,
+                        },
+                    });
+                }
+            }
             if (!msg.content) {
                 responseData = {};
             }
@@ -132,16 +144,22 @@ function convertToGeminiMessages(messages, includeBuiltinSystemPrompt = true) {
                     responseData = { content: contentToParse };
                 }
             }
+            // Build parts array with functionResponse and optional images
+            const parts = [
+                {
+                    functionResponse: {
+                        name: functionName,
+                        response: responseData,
+                    },
+                },
+            ];
+            // Add images as inline data parts
+            if (imageParts.length > 0) {
+                parts.push(...imageParts);
+            }
             contents.push({
                 role: 'user',
-                parts: [
-                    {
-                        functionResponse: {
-                            name: functionName,
-                            response: responseData,
-                        },
-                    },
-                ],
+                parts,
             });
             continue;
         }

package/dist/api/responses.js

@@ -163,11 +163,38 @@ function convertToResponseInput(messages, includeBuiltinSystemPrompt = true) {
         }
         // Tool 消息：转换为 function_call_output
         if (msg.role === 'tool' && msg.tool_call_id) {
-            result.push({
-                type: 'function_call_output',
-                call_id: msg.tool_call_id,
-                output: msg.content,
-            });
+            // Handle multimodal tool results with images
+            if (msg.images && msg.images.length > 0) {
+                // For Responses API, we need to include images in a structured way
+                // The output can be an array of content items
+                const outputContent = [];
+                // Add text content
+                if (msg.content) {
+                    outputContent.push({
+                        type: 'input_text',
+                        text: msg.content,
+                    });
+                }
+                // Add images as base64 data URLs (Responses API format)
+                for (const image of msg.images) {
+                    outputContent.push({
+                        type: 'input_image',
+                        image_url: `data:${image.mimeType};base64,${image.data}`,
+                    });
+                }
+                result.push({
+                    type: 'function_call_output',
+                    call_id: msg.tool_call_id,
+                    output: outputContent,
+                });
+            }
+            else {
+                result.push({
+                    type: 'function_call_output',
+                    call_id: msg.tool_call_id,
+                    output: msg.content,
+                });
+            }
             continue;
         }
     }

package/dist/api/systemPrompt.js

@@ -79,6 +79,7 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 ## Execution Strategy - BALANCE ACTION & ANALYSIS
 
 ### Rigorous Coding Habits
+- **Location Code**: Must First use a search tool to locate the line number of the code, then use \`filesystem-read\` to read the code content
 - **Boundary verification**: MUST use \`filesystem-read\` to identify complete code boundaries before ANY edit. Never guess line numbers or code structure
 - **Impact analysis**: Consider modification impact and conflicts with existing business logic
 - **Optimal solution**: Avoid hardcoding/shortcuts unless explicitly requested
@@ -114,10 +115,9 @@ PLACEHOLDER_FOR_WORKFLOW_SECTION
 **CRITICAL: BOUNDARY-FIRST EDITING**
 
 **MANDATORY WORKFLOW:**
-1. **LOCATE** - \`ace-semantic_search\` / \`ace-text_search\` / \`ace-find_definition\`
-2. **READ & VERIFY** - Use \`filesystem-read\` to identify COMPLETE units (functions: opening to closing brace, markup: full tags, check indentation)
-3. **COPY COMPLETE CODE** - Remove line numbers, preserve all content
-4. **EDIT** - \`filesystem-edit_search\` (fuzzy match, safer) or \`filesystem-edit\` (line-based, for add/delete)
+1. **READ & VERIFY** - Use \`filesystem-read\` to identify COMPLETE units (functions: opening to closing brace, markup: full tags, check indentation)
+2. **COPY COMPLETE CODE** - Remove line numbers, preserve all content
+3. **EDIT** - \`filesystem-edit_search\` (fuzzy match, safer) or \`filesystem-edit\` (line-based, for add/delete)
 
 **BATCH OPERATIONS:** Modify 2+ files? Use batch: \`filesystem-read(filePath=["a.ts","b.ts"])\` or \`filesystem-edit_search(filePath=[{path:"a.ts",...},{path:"b.ts",...}])\`
 

package/dist/hooks/useFilePicker.d.ts

@@ -10,7 +10,7 @@ export declare function useFilePicker(buffer: TextBuffer, triggerUpdate: () => v
     atSymbolPosition: number;
     setAtSymbolPosition: (_pos: number) => void;
     filteredFileCount: number;
-    searchMode: "content" | "file";
+    searchMode: "file" | "content";
     updateFilePickerState: (_text: string, cursorPos: number) => void;
     handleFileSelect: (filePath: string) => Promise<void>;
     handleFilteredCountChange: (count: number) => void;

package/dist/mcp/filesystem.d.ts

@@ -1,4 +1,4 @@
-import type { EditBySearchConfig, EditByLineConfig, EditBySearchResult, EditByLineResult } from './types/filesystem.types.js';
+import type { EditBySearchConfig, EditByLineConfig, EditBySearchResult, EditByLineResult, SingleFileReadResult, MultipleFilesReadResult } from './types/filesystem.types.js';
 /**
  * Filesystem MCP Service
  * Provides basic file operations: read, create, and delete files
@@ -10,6 +10,30 @@ export declare class FilesystemMCPService {
      */
     private readonly prettierSupportedExtensions;
     constructor(basePath?: string);
+    /**
+     * Check if a file is an image based on extension
+     * @param filePath - Path to the file
+     * @returns True if the file is an image
+     */
+    private isImageFile;
+    /**
+     * Check if a file is an Office document based on extension
+     * @param filePath - Path to the file
+     * @returns True if the file is an Office document
+     */
+    private isOfficeFile;
+    /**
+     * Get MIME type for an image file
+     * @param filePath - Path to the file
+     * @returns MIME type or undefined if not an image
+     */
+    private getImageMimeType;
+    /**
+     * Read image file and convert to base64
+     * @param fullPath - Full path to the image file
+     * @returns ImageContent object with base64 data
+     */
+    private readImageAsBase64;
     /**
      * Extract relevant symbol information for a specific line range
      * This provides context that helps AI make more accurate modifications
@@ -29,31 +53,18 @@ export declare class FilesystemMCPService {
     /**
      * Get the content of a file with optional line range
      * Enhanced with symbol information for better AI context
+     * Supports multimodal content (text + images)
      * @param filePath - Path to the file (relative to base path or absolute) or array of file paths or array of file config objects
      * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1). Used for single file or as default for array of strings
      * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to file end). Used for single file or as default for array of strings
-     * @returns Object containing the requested content with line numbers and metadata
+     * @returns Object containing the requested content with line numbers and metadata (supports multimodal content)
      * @throws Error if file doesn't exist or cannot be read
      */
     getFileContent(filePath: string | string[] | Array<{
         path: string;
         startLine?: number;
         endLine?: number;
-    }>, startLine?: number, endLine?: number): Promise<{
-        content: string;
-        startLine: number;
-        endLine: number;
-        totalLines: number;
-    } | {
-        content: string;
-        files: Array<{
-            path: string;
-            startLine: number;
-            endLine: number;
-            totalLines: number;
-        }>;
-        totalFiles: number;
-    }>;
+    }>, startLine?: number, endLine?: number): Promise<SingleFileReadResult | MultipleFilesReadResult>;
     /**
      * Create a new file with specified content
      * @param filePath - Path where the file should be created

package/dist/mcp/filesystem.js

@@ -5,17 +5,19 @@ import * as prettier from 'prettier';
 import { vscodeConnection } from '../utils/vscodeConnection.js';
 import { incrementalSnapshotManager } from '../utils/incrementalSnapshot.js';
 import { tryUnescapeFix, trimPairIfPossible, isOverEscaped, } from '../utils/escapeHandler.js';
+import { IMAGE_MIME_TYPES, OFFICE_FILE_TYPES } from './types/filesystem.types.js';
 // Utility functions
 import { calculateSimilarity, normalizeForDisplay, } from './utils/filesystem/similarity.utils.js';
 import { analyzeCodeStructure, findSmartContextBoundaries, } from './utils/filesystem/code-analysis.utils.js';
 import { findClosestMatches, generateDiffMessage, } from './utils/filesystem/match-finder.utils.js';
 import { parseEditBySearchParams, parseEditByLineParams, executeBatchOperation, } from './utils/filesystem/batch-operations.utils.js';
 import { tryFixPath } from './utils/filesystem/path-fixer.utils.js';
+import { readOfficeDocument } from './utils/filesystem/office-parser.utils.js';
 // ACE Code Search utilities for symbol parsing
 import { parseFileSymbols } from './utils/aceCodeSearch/symbol.utils.js';
 // Notebook utilities for automatic note retrieval
 import { queryNotebook } from '../utils/notebookManager.js';
-const { resolve, dirname, isAbsolute } = path;
+const { resolve, dirname, isAbsolute, extname } = path;
 /**
  * Filesystem MCP Service
  * Provides basic file operations: read, create, and delete files
@@ -55,6 +57,57 @@ export class FilesystemMCPService {
         });
         this.basePath = resolve(basePath);
     }
+    /**
+     * Check if a file is an image based on extension
+     * @param filePath - Path to the file
+     * @returns True if the file is an image
+     */
+    isImageFile(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        return ext in IMAGE_MIME_TYPES;
+    }
+    /**
+     * Check if a file is an Office document based on extension
+     * @param filePath - Path to the file
+     * @returns True if the file is an Office document
+     */
+    isOfficeFile(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        return ext in OFFICE_FILE_TYPES;
+    }
+    /**
+     * Get MIME type for an image file
+     * @param filePath - Path to the file
+     * @returns MIME type or undefined if not an image
+     */
+    getImageMimeType(filePath) {
+        const ext = extname(filePath).toLowerCase();
+        return IMAGE_MIME_TYPES[ext];
+    }
+    /**
+     * Read image file and convert to base64
+     * @param fullPath - Full path to the image file
+     * @returns ImageContent object with base64 data
+     */
+    async readImageAsBase64(fullPath) {
+        try {
+            const mimeType = this.getImageMimeType(fullPath);
+            if (!mimeType) {
+                return null;
+            }
+            const buffer = await fs.readFile(fullPath);
+            const base64Data = buffer.toString('base64');
+            return {
+                type: 'image',
+                data: base64Data,
+                mimeType,
+            };
+        }
+        catch (error) {
+            console.error(`Failed to read image ${fullPath}:`, error);
+            return null;
+        }
+    }
     /**
      * Extract relevant symbol information for a specific line range
      * This provides context that helps AI make more accurate modifications
@@ -156,10 +209,11 @@ export class FilesystemMCPService {
     /**
      * Get the content of a file with optional line range
      * Enhanced with symbol information for better AI context
+     * Supports multimodal content (text + images)
      * @param filePath - Path to the file (relative to base path or absolute) or array of file paths or array of file config objects
      * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1). Used for single file or as default for array of strings
      * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to file end). Used for single file or as default for array of strings
-     * @returns Object containing the requested content with line numbers and metadata
+     * @returns Object containing the requested content with line numbers and metadata (supports multimodal content)
      * @throws Error if file doesn't exist or cannot be read
      */
     async getFileContent(filePath, startLine, endLine) {
@@ -167,7 +221,7 @@ export class FilesystemMCPService {
             // Handle array of files
             if (Array.isArray(filePath)) {
                 const filesData = [];
-                const allContents = [];
+                const multimodalContent = [];
                 for (const fileItem of filePath) {
                     try {
                         // Support both string format and object format
@@ -196,7 +250,10 @@ export class FilesystemMCPService {
                         if (stats.isDirectory()) {
                             const dirFiles = await this.listFiles(file);
                             const fileList = dirFiles.join('\n');
-                            allContents.push(`📁 Directory: ${file}\n${fileList}`);
+                            multimodalContent.push({
+                                type: 'text',
+                                text: `📁 Directory: ${file}\n${fileList}`,
+                            });
                             filesData.push({
                                 path: file,
                                 startLine: 1,
@@ -205,6 +262,44 @@ export class FilesystemMCPService {
                             });
                             continue;
                         }
+                        // Check if this is an image file
+                        if (this.isImageFile(fullPath)) {
+                            const imageContent = await this.readImageAsBase64(fullPath);
+                            if (imageContent) {
+                                // Add text description first
+                                multimodalContent.push({
+                                    type: 'text',
+                                    text: `🖼️  Image: ${file} (${imageContent.mimeType})`,
+                                });
+                                // Add image content
+                                multimodalContent.push(imageContent);
+                                filesData.push({
+                                    path: file,
+                                    isImage: true,
+                                    mimeType: imageContent.mimeType,
+                                });
+                                continue;
+                            }
+                        }
+                        // Check if this is an Office document file
+                        if (this.isOfficeFile(fullPath)) {
+                            const docContent = await readOfficeDocument(fullPath);
+                            if (docContent) {
+                                // Add text description first
+                                multimodalContent.push({
+                                    type: 'text',
+                                    text: `📄 ${docContent.fileType.toUpperCase()} Document: ${file}`,
+                                });
+                                // Add document content
+                                multimodalContent.push(docContent);
+                                filesData.push({
+                                    path: file,
+                                    isDocument: true,
+                                    fileType: docContent.fileType,
+                                });
+                                continue;
+                            }
+                        }
                         const content = await fs.readFile(fullPath, 'utf-8');
                         const lines = content.split('\n');
                         const totalLines = lines.length;
@@ -244,7 +339,10 @@ export class FilesystemMCPService {
                         if (notebookInfo) {
                             fileContent += notebookInfo;
                         }
-                        allContents.push(fileContent);
+                        multimodalContent.push({
+                            type: 'text',
+                            text: fileContent,
+                        });
                         filesData.push({
                             path: file,
                             startLine: start,
@@ -256,11 +354,14 @@ export class FilesystemMCPService {
                         const errorMsg = error instanceof Error ? error.message : 'Unknown error';
                         // Extract file path for error message
                         const filePath = typeof fileItem === 'string' ? fileItem : fileItem.path;
-                        allContents.push(`❌ ${filePath}: ${errorMsg}`);
+                        multimodalContent.push({
+                            type: 'text',
+                            text: `❌ ${filePath}: ${errorMsg}`,
+                        });
                     }
                 }
                 return {
-                    content: allContents.join('\n\n'),
+                    content: multimodalContent,
                     files: filesData,
                     totalFiles: filePath.length,
                 };
@@ -284,6 +385,41 @@ export class FilesystemMCPService {
                     totalLines: lines.length,
                 };
             }
+            // Check if this is an image file
+            if (this.isImageFile(fullPath)) {
+                const imageContent = await this.readImageAsBase64(fullPath);
+                if (imageContent) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `🖼️  Image: ${filePath} (${imageContent.mimeType})`,
+                            },
+                            imageContent,
+                        ],
+                        isImage: true,
+                        mimeType: imageContent.mimeType,
+                    };
+                }
+            }
+            // Check if this is an Office document file
+            if (this.isOfficeFile(fullPath)) {
+                const docContent = await readOfficeDocument(fullPath);
+                if (docContent) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `📄 ${docContent.fileType.toUpperCase()} Document: ${filePath}`,
+                            },
+                            docContent,
+                        ],
+                        isDocument: true,
+                        fileType: docContent.fileType,
+                    };
+                }
+            }
+            // Text file processing
             const content = await fs.readFile(fullPath, 'utf-8');
             // Parse lines
             const lines = content.split('\n');
@@ -1090,7 +1226,7 @@ export const filesystemService = new FilesystemMCPService();
 export const mcpTools = [
     {
         name: 'filesystem-read',
-        description: 'Read file content with line numbers. **Read only when the actual file or folder path is found or provided by the user, do not make random guesses,Search for specific documents or line numbers before reading more accurately** **SUPPORTS MULTIPLE FILES WITH FLEXIBLE LINE RANGES**: Pass either (1) a single file path (string), (2) array of file paths (strings) with unified startLine/endLine, or (3) array of file config objects with per-file line ranges. **INTEGRATED DIRECTORY LISTING**: When filePath is a directory, automatically lists its contents instead of throwing error. ⚠️ **IMPORTANT WORKFLOW**: (1) ALWAYS use ACE search tools FIRST (ace-text_search/ace-search_symbols/ace-file_outline) to locate the relevant code, (2) ONLY use filesystem-read when you know the approximate location and need precise line numbers for editing. **ANTI-PATTERN**: Reading files line-by-line from the top wastes tokens - use search instead! **USAGE**: Call without parameters to read entire file(s), or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for precise editing. **EXAMPLES**: (A) Unified: filePath=["a.ts", "b.ts"], startLine=1, endLine=500 reads lines 1-500 from both. (B) Per-file: filePath=[{path:"a.ts", startLine:1, endLine:300}, {path:"b.ts", startLine:100, endLine:550}] reads different ranges from each file. (C) Directory: filePath="./src" returns list of files in src/.',
+        description: 'Read file content with line numbers and multimodal support (text + images + Office documents). **MULTIMODAL SUPPORT**: Automatically detects and processes: (1) Image files (.png, .jpg, .jpeg, .gif, .webp, .bmp, .svg) - returns base64-encoded image data, (2) Office documents (.pdf, .docx, .doc, .xlsx, .xls, .pptx, .ppt) - extracts and returns readable text content. All returned in MCP content format for AI analysis. **Read only when the actual file or folder path is found or provided by the user, do not make random guesses,Search for specific documents or line numbers before reading more accurately** **SUPPORTS MULTIPLE FILES WITH FLEXIBLE LINE RANGES**: Pass either (1) a single file path (string), (2) array of file paths (strings) with unified startLine/endLine, or (3) array of file config objects with per-file line ranges. **INTEGRATED DIRECTORY LISTING**: When filePath is a directory, automatically lists its contents instead of throwing error. ⚠️ **IMPORTANT WORKFLOW**: (1) ALWAYS use ACE search tools FIRST (ace-text_search/ace-search_symbols/ace-file_outline) to locate the relevant code, (2) ONLY use filesystem-read when you know the approximate location and need precise line numbers for editing. **ANTI-PATTERN**: Reading files line-by-line from the top wastes tokens - use search instead! **USAGE**: Call without parameters to read entire file(s), or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for text files or multimodal content array for images/documents. **EXAMPLES**: (A) Unified: filePath=["a.ts", "b.ts"], startLine=1, endLine=500 reads lines 1-500 from both. (B) Per-file: filePath=[{path:"a.ts", startLine:1, endLine:300}, {path:"b.ts", startLine:100, endLine:550}] reads different ranges from each file. (C) Directory: filePath="./src" returns list of files in src/. (D) Image: filePath="screenshot.png" returns multimodal content with base64 image data. (E) Office: filePath="report.pdf" or "data.xlsx" extracts and returns document text.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/mcp/types/filesystem.types.d.ts

@@ -2,6 +2,51 @@
  * Type definitions for Filesystem MCP Service
  */
 import type { Diagnostic } from '../../utils/vscodeConnection.js';
+/**
+ * MCP Content Types - supports multimodal content
+ */
+export type MCPContentType = 'text' | 'image' | 'document';
+/**
+ * Text content block
+ */
+export interface TextContent {
+    type: 'text';
+    text: string;
+}
+/**
+ * Image content block (base64 encoded)
+ */
+export interface ImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+/**
+ * Document content block (for Office files like PDF, Word, Excel, PPT)
+ */
+export interface DocumentContent {
+    type: 'document';
+    text: string;
+    fileType: 'pdf' | 'word' | 'excel' | 'powerpoint';
+    metadata?: {
+        pages?: number;
+        sheets?: string[];
+        slides?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Multimodal content - array of text, image, and document blocks
+ */
+export type MultimodalContent = Array<TextContent | ImageContent | DocumentContent>;
+/**
+ * Supported image MIME types
+ */
+export declare const IMAGE_MIME_TYPES: Record<string, string>;
+/**
+ * Supported Office document types
+ */
+export declare const OFFICE_FILE_TYPES: Record<string, 'pdf' | 'word' | 'excel' | 'powerpoint'>;
 /**
  * Structure analysis result for code validation
  */
@@ -51,6 +96,36 @@ export interface FileReadConfig {
     startLine?: number;
     endLine?: number;
 }
+/**
+ * Single file read result
+ */
+export interface SingleFileReadResult {
+    content: string | MultimodalContent;
+    startLine?: number;
+    endLine?: number;
+    totalLines?: number;
+    isImage?: boolean;
+    isDocument?: boolean;
+    fileType?: 'pdf' | 'word' | 'excel' | 'powerpoint';
+    mimeType?: string;
+}
+/**
+ * Multiple files read result
+ */
+export interface MultipleFilesReadResult {
+    content: string | MultimodalContent;
+    files: Array<{
+        path: string;
+        startLine?: number;
+        endLine?: number;
+        totalLines?: number;
+        isImage?: boolean;
+        isDocument?: boolean;
+        fileType?: 'pdf' | 'word' | 'excel' | 'powerpoint';
+        mimeType?: string;
+    }>;
+    totalFiles: number;
+}
 /**
  * Edit by search configuration
  */

package/dist/mcp/types/filesystem.types.js

@@ -1,4 +1,27 @@
 /**
  * Type definitions for Filesystem MCP Service
  */
-export {};
+/**
+ * Supported image MIME types
+ */
+export const IMAGE_MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+};
+/**
+ * Supported Office document types
+ */
+export const OFFICE_FILE_TYPES = {
+    '.pdf': 'pdf',
+    '.docx': 'word',
+    '.doc': 'word',
+    '.xlsx': 'excel',
+    '.xls': 'excel',
+    '.pptx': 'powerpoint',
+    '.ppt': 'powerpoint',
+};

package/dist/mcp/utils/filesystem/office-parser.utils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Office file parsing utilities
+ * Handles parsing of PDF, Word, Excel, and PowerPoint files
+ */
+import type { DocumentContent } from '../../types/filesystem.types.js';
+/**
+ * Parse Word document (.docx, .doc)
+ * @param fullPath - Full path to the Word document
+ * @returns DocumentContent object with extracted text
+ */
+export declare function parseWordDocument(fullPath: string): Promise<DocumentContent | null>;
+/**
+ * Parse PDF document
+ * @param fullPath - Full path to the PDF file
+ * @returns DocumentContent object with extracted text
+ */
+export declare function parsePDFDocument(fullPath: string): Promise<DocumentContent | null>;
+/**
+ * Parse Excel spreadsheet (.xlsx, .xls)
+ * @param fullPath - Full path to the Excel file
+ * @returns DocumentContent object with extracted text
+ */
+export declare function parseExcelDocument(fullPath: string): Promise<DocumentContent | null>;
+/**
+ * Parse PowerPoint presentation (.pptx, .ppt)
+ * Note: PowerPoint parsing is complex and requires unzipping the .pptx file
+ * This is a placeholder implementation
+ * @param fullPath - Full path to the PowerPoint file
+ * @returns DocumentContent object with extracted text
+ */
+export declare function parsePowerPointDocument(fullPath: string): Promise<DocumentContent | null>;
+/**
+ * Get Office file type based on extension
+ * @param filePath - Path to the file
+ * @returns File type or undefined
+ */
+export declare function getOfficeFileType(filePath: string): 'pdf' | 'word' | 'excel' | 'powerpoint' | undefined;
+/**
+ * Main entry point: Read and parse Office document
+ * @param fullPath - Full path to the Office document
+ * @returns DocumentContent object with extracted text
+ */
+export declare function readOfficeDocument(fullPath: string): Promise<DocumentContent | null>;

package/dist/mcp/utils/filesystem/office-parser.utils.js

@@ -0,0 +1,163 @@
+/**
+ * Office file parsing utilities
+ * Handles parsing of PDF, Word, Excel, and PowerPoint files
+ */
+import { promises as fs } from 'fs';
+import mammoth from 'mammoth';
+import * as XLSX from 'xlsx';
+import { OFFICE_FILE_TYPES } from '../../types/filesystem.types.js';
+import * as path from 'path';
+/**
+ * Parse Word document (.docx, .doc)
+ * @param fullPath - Full path to the Word document
+ * @returns DocumentContent object with extracted text
+ */
+export async function parseWordDocument(fullPath) {
+    try {
+        const buffer = await fs.readFile(fullPath);
+        const result = await mammoth.extractRawText({ buffer });
+        return {
+            type: 'document',
+            text: result.value,
+            fileType: 'word',
+            metadata: {
+                messages: result.messages.length > 0 ? result.messages : undefined,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Failed to parse Word document ${fullPath}:`, error);
+        return null;
+    }
+}
+/**
+ * Parse PDF document
+ * @param fullPath - Full path to the PDF file
+ * @returns DocumentContent object with extracted text
+ */
+export async function parsePDFDocument(fullPath) {
+    try {
+        // Lazy import pdf-parse to avoid loading pdfjs-dist at startup
+        // pdfjs-dist requires browser APIs (DOMMatrix) which causes errors in Node.js
+        const { PDFParse } = await import('pdf-parse');
+        const buffer = await fs.readFile(fullPath);
+        const uint8Array = new Uint8Array(buffer);
+        // Create parser instance and parse
+        const parser = new PDFParse({ data: uint8Array });
+        const data = await parser.getText();
+        return {
+            type: 'document',
+            text: data.text,
+            fileType: 'pdf',
+            metadata: {
+                pages: data.total,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Failed to parse PDF document ${fullPath}:`, error);
+        return null;
+    }
+}
+/**
+ * Parse Excel spreadsheet (.xlsx, .xls)
+ * @param fullPath - Full path to the Excel file
+ * @returns DocumentContent object with extracted text
+ */
+export async function parseExcelDocument(fullPath) {
+    try {
+        const buffer = await fs.readFile(fullPath);
+        const workbook = XLSX.read(buffer, { type: 'buffer' });
+        const sheets = [];
+        let allText = '';
+        workbook.SheetNames.forEach(sheetName => {
+            sheets.push(sheetName);
+            const worksheet = workbook.Sheets[sheetName];
+            if (worksheet) {
+                const sheetText = XLSX.utils.sheet_to_txt(worksheet);
+                allText += `\n\n=== Sheet: ${sheetName} ===\n${sheetText}`;
+            }
+        });
+        return {
+            type: 'document',
+            text: allText.trim(),
+            fileType: 'excel',
+            metadata: {
+                sheets,
+                sheetCount: sheets.length,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Failed to parse Excel document ${fullPath}:`, error);
+        return null;
+    }
+}
+/**
+ * Parse PowerPoint presentation (.pptx, .ppt)
+ * Note: PowerPoint parsing is complex and requires unzipping the .pptx file
+ * This is a placeholder implementation
+ * @param fullPath - Full path to the PowerPoint file
+ * @returns DocumentContent object with extracted text
+ */
+export async function parsePowerPointDocument(fullPath) {
+    try {
+        // PowerPoint parsing requires extracting and parsing XML from the .pptx archive
+        // A full implementation would use JSZip to extract slide XML files
+        // and parse them to extract text content
+        // For now, return a placeholder message
+        return {
+            type: 'document',
+            text: '[PowerPoint parsing not fully implemented yet. Please use a specialized tool to extract text from .pptx files.]',
+            fileType: 'powerpoint',
+            metadata: {
+                note: 'PowerPoint text extraction requires additional implementation',
+                suggestion: 'Consider using external tools or libraries like python-pptx for full PowerPoint text extraction',
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Failed to parse PowerPoint document ${fullPath}:`, error);
+        return null;
+    }
+}
+/**
+ * Get Office file type based on extension
+ * @param filePath - Path to the file
+ * @returns File type or undefined
+ */
+export function getOfficeFileType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return OFFICE_FILE_TYPES[ext];
+}
+/**
+ * Main entry point: Read and parse Office document
+ * @param fullPath - Full path to the Office document
+ * @returns DocumentContent object with extracted text
+ */
+export async function readOfficeDocument(fullPath) {
+    const fileType = getOfficeFileType(fullPath);
+    if (!fileType) {
+        return null;
+    }
+    let docContent = null;
+    switch (fileType) {
+        case 'word': {
+            docContent = await parseWordDocument(fullPath);
+            break;
+        }
+        case 'pdf': {
+            docContent = await parsePDFDocument(fullPath);
+            break;
+        }
+        case 'excel': {
+            docContent = await parseExcelDocument(fullPath);
+            break;
+        }
+        case 'powerpoint': {
+            docContent = await parsePowerPointDocument(fullPath);
+            break;
+        }
+    }
+    return docContent;
+}

package/dist/ui/pages/ChatScreen.js

@@ -472,6 +472,10 @@ export default function ChatScreen({ skipWelcome }) {
         }
     });
     const handleHistorySelect = async (selectedIndex, message, images) => {
+        // Clear context percentage and usage when user performs history rollback
+        setCurrentContextPercentage(0);
+        currentContextPercentageRef.current = 0;
+        streamingState.setContextUsage(null);
         // Count total files that will be rolled back (from selectedIndex onwards)
         let totalFileCount = 0;
         for (const [index, count] of snapshotState.snapshotFileCount.entries()) {

package/dist/utils/toolExecutor.d.ts

@@ -1,5 +1,6 @@
 import type { SubAgentMessage } from './subAgentExecutor.js';
 import type { ConfirmationResult } from '../ui/components/ToolConfirmation.js';
+import type { ImageContent } from '../api/types.js';
 export interface ToolCall {
     id: string;
     type: 'function';
@@ -12,6 +13,7 @@ export interface ToolResult {
     tool_call_id: string;
     role: 'tool';
     content: string;
+    images?: ImageContent[];
 }
 export type SubAgentMessageCallback = (message: SubAgentMessage) => void;
 export interface ToolConfirmationCallback {

package/dist/utils/toolExecutor.js

@@ -1,5 +1,59 @@
 import { executeMCPTool } from './mcpToolsManager.js';
 import { subAgentService } from '../mcp/subagent.js';
+/**
+ * Check if a value is a multimodal content array
+ */
+function isMultimodalContent(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((item) => item &&
+            typeof item === 'object' &&
+            (item.type === 'text' || item.type === 'image')));
+}
+/**
+ * Extract images and text content from a result that may be multimodal
+ */
+function extractMultimodalContent(result) {
+    // Check if result has multimodal content array
+    let contentToCheck = result;
+    // Handle wrapped results (e.g., {content: [...], files: [...], totalFiles: n})
+    if (result && typeof result === 'object' && result.content) {
+        contentToCheck = result.content;
+    }
+    if (isMultimodalContent(contentToCheck)) {
+        const textParts = [];
+        const images = [];
+        for (const item of contentToCheck) {
+            if (item.type === 'text') {
+                textParts.push(item.text);
+            }
+            else if (item.type === 'image') {
+                images.push({
+                    type: 'image',
+                    data: item.data,
+                    mimeType: item.mimeType,
+                });
+            }
+        }
+        // If we extracted the content, we need to rebuild the result
+        if (result && typeof result === 'object' && result.content === contentToCheck) {
+            // Create a new result object with text content instead of multimodal array
+            const newResult = { ...result, content: textParts.join('\n\n') };
+            return {
+                textContent: JSON.stringify(newResult),
+                images: images.length > 0 ? images : undefined,
+            };
+        }
+        return {
+            textContent: textParts.join('\n\n'),
+            images: images.length > 0 ? images : undefined,
+        };
+    }
+    // Not multimodal, return as JSON string
+    return {
+        textContent: JSON.stringify(result),
+    };
+}
 /**
  * Execute a single tool call and return the result
  */
@@ -48,10 +102,13 @@ export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSu
         }
         // Regular tool execution
         const result = await executeMCPTool(toolCall.function.name, args, abortSignal, onTokenUpdate);
+        // Extract multimodal content (text + images)
+        const { textContent, images } = extractMultimodalContent(result);
         return {
             tool_call_id: toolCall.id,
             role: 'tool',
-            content: JSON.stringify(result),
+            content: textContent,
+            images,
         };
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.4.6",
+	"version": "0.4.7",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -45,8 +45,6 @@
 		"better-sqlite3": "^12.4.1",
 		"cli-highlight": "^2.1.11",
 		"diff": "^8.0.2",
-		"marked": "^15.0.6",
-		"marked-terminal": "^7.3.0",
 		"fzf": "^0.5.2",
 		"http-proxy-agent": "^7.0.2",
 		"https-proxy-agent": "^7.0.6",
@@ -56,18 +54,25 @@
 		"ink-select-input": "^6.2.0",
 		"ink-spinner": "^5.0.0",
 		"ink-text-input": "^6.0.0",
+		"mammoth": "^1.11.0",
+		"marked": "^15.0.6",
+		"marked-terminal": "^7.3.0",
 		"meow": "^11.0.0",
+		"pdf-parse": "^2.4.5",
+		"pptx-parser": "^1.1.7-beta.9",
 		"prettier": "^2.8.7",
 		"puppeteer-core": "^24.25.0",
 		"react": "^18.2.0",
 		"string-width": "^7.2.0",
 		"tiktoken": "^1.0.22",
-		"ws": "^8.14.2"
+		"ws": "^8.14.2",
+		"xlsx": "^0.18.5"
 	},
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "^3.0.1",
 		"@types/diff": "^7.0.2",
 		"@types/marked-terminal": "^6.1.1",
+		"@types/pdf-parse": "^1.1.5",
 		"@types/prettier": "^2.7.3",
 		"@types/react": "^18.0.32",
 		"@types/ws": "^8.5.8",