snow-ai 0.2.8 → 0.2.10

package/dist/mcp/filesystem.d.ts

@@ -11,6 +11,35 @@ interface SearchResult {
     matches: SearchMatch[];
     searchedFiles: number;
 }
+interface StructureAnalysis {
+    bracketBalance: {
+        curly: {
+            open: number;
+            close: number;
+            balanced: boolean;
+        };
+        round: {
+            open: number;
+            close: number;
+            balanced: boolean;
+        };
+        square: {
+            open: number;
+            close: number;
+            balanced: boolean;
+        };
+    };
+    htmlTags?: {
+        unclosedTags: string[];
+        unopenedTags: string[];
+        balanced: boolean;
+    };
+    indentationWarnings: string[];
+    codeBlockBoundary?: {
+        isInCompleteBlock: boolean;
+        suggestion?: string;
+    };
+}
 /**
  * Filesystem MCP Service
  * Provides basic file operations: read, create, and delete files
@@ -18,6 +47,16 @@ interface SearchResult {
 export declare class FilesystemMCPService {
     private basePath;
     constructor(basePath?: string);
+    /**
+     * Analyze code structure for balance and completeness
+     * Helps AI identify bracket mismatches, unclosed tags, and boundary issues
+     */
+    private analyzeCodeStructure;
+    /**
+     * Find smart context boundaries for editing
+     * Expands context to include complete code blocks when possible
+     */
+    private findSmartContextBoundaries;
     /**
      * Get the content of a file with specified line range
      * @param filePath - Path to the file (relative to base path or absolute)
@@ -76,8 +115,8 @@ export declare class FilesystemMCPService {
     }>;
     /**
      * Edit a file by replacing lines within a specified range
-     * IMPORTANT: This tool enforces small, precise edits (max 15 lines per edit) to ensure accuracy.
-     * For larger changes, make multiple sequential edits instead of one large edit.
+     * BEST PRACTICE: Keep edits small and focused (≤15 lines recommended) for better accuracy.
+     * For larger changes, make multiple parallel edits to non-overlapping sections instead of one large edit.
      *
      * @param filePath - Path to the file to edit
      * @param startLine - Starting line number (1-indexed, inclusive) - get from filesystem_read output
@@ -85,7 +124,7 @@ export declare class FilesystemMCPService {
      * @param newContent - New content to replace the specified lines (WITHOUT line numbers)
      * @param contextLines - Number of context lines to return before and after the edit (default: 8)
      * @returns Object containing success message, precise before/after comparison, and diagnostics
-     * @throws Error if file editing fails or if the edit range is too large
+     * @throws Error if file editing fails
      */
     editFile(filePath: string, startLine: number, endLine: number, newContent: string, contextLines?: number): Promise<{
         message: string;
@@ -96,6 +135,7 @@ export declare class FilesystemMCPService {
         contextEndLine: number;
         totalLines: number;
         linesModified: number;
+        structureAnalysis?: StructureAnalysis;
         diagnostics?: Diagnostic[];
     }>;
     /**

package/dist/mcp/filesystem.js

@@ -17,6 +17,178 @@ export class FilesystemMCPService {
         });
         this.basePath = resolve(basePath);
     }
+    /**
+     * Analyze code structure for balance and completeness
+     * Helps AI identify bracket mismatches, unclosed tags, and boundary issues
+     */
+    analyzeCodeStructure(_content, filePath, editedLines) {
+        const analysis = {
+            bracketBalance: {
+                curly: { open: 0, close: 0, balanced: true },
+                round: { open: 0, close: 0, balanced: true },
+                square: { open: 0, close: 0, balanced: true }
+            },
+            indentationWarnings: []
+        };
+        // Count brackets in the edited content
+        const editedContent = editedLines.join('\n');
+        // Remove string literals and comments to avoid false positives
+        const cleanContent = editedContent
+            .replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g, '""') // Remove strings
+            .replace(/\/\/.*$/gm, '') // Remove single-line comments
+            .replace(/\/\*[\s\S]*?\*\//g, ''); // Remove multi-line comments
+        // Count brackets
+        analysis.bracketBalance.curly.open = (cleanContent.match(/\{/g) || []).length;
+        analysis.bracketBalance.curly.close = (cleanContent.match(/\}/g) || []).length;
+        analysis.bracketBalance.curly.balanced =
+            analysis.bracketBalance.curly.open === analysis.bracketBalance.curly.close;
+        analysis.bracketBalance.round.open = (cleanContent.match(/\(/g) || []).length;
+        analysis.bracketBalance.round.close = (cleanContent.match(/\)/g) || []).length;
+        analysis.bracketBalance.round.balanced =
+            analysis.bracketBalance.round.open === analysis.bracketBalance.round.close;
+        analysis.bracketBalance.square.open = (cleanContent.match(/\[/g) || []).length;
+        analysis.bracketBalance.square.close = (cleanContent.match(/\]/g) || []).length;
+        analysis.bracketBalance.square.balanced =
+            analysis.bracketBalance.square.open === analysis.bracketBalance.square.close;
+        // HTML/JSX tag analysis (for .html, .jsx, .tsx, .vue files)
+        const isMarkupFile = /\.(html|jsx|tsx|vue)$/i.test(filePath);
+        if (isMarkupFile) {
+            const tagPattern = /<\/?([a-zA-Z][a-zA-Z0-9-]*)[^>]*>/g;
+            const selfClosingPattern = /<[a-zA-Z][a-zA-Z0-9-]*[^>]*\/>/g;
+            // Remove self-closing tags
+            const contentWithoutSelfClosing = cleanContent.replace(selfClosingPattern, '');
+            const tags = [];
+            const unclosedTags = [];
+            const unopenedTags = [];
+            let match;
+            while ((match = tagPattern.exec(contentWithoutSelfClosing)) !== null) {
+                const isClosing = match[0]?.startsWith('</');
+                const tagName = match[1]?.toLowerCase();
+                if (!tagName)
+                    continue;
+                if (isClosing) {
+                    const lastOpenTag = tags.pop();
+                    if (!lastOpenTag || lastOpenTag !== tagName) {
+                        unopenedTags.push(tagName);
+                        if (lastOpenTag)
+                            tags.push(lastOpenTag); // Put it back
+                    }
+                }
+                else {
+                    tags.push(tagName);
+                }
+            }
+            unclosedTags.push(...tags);
+            analysis.htmlTags = {
+                unclosedTags,
+                unopenedTags,
+                balanced: unclosedTags.length === 0 && unopenedTags.length === 0
+            };
+        }
+        // Check indentation consistency
+        const lines = editedContent.split('\n');
+        const indents = lines
+            .filter(line => line.trim().length > 0)
+            .map(line => {
+            const match = line.match(/^(\s*)/);
+            return match ? match[1] : '';
+        })
+            .filter((indent) => indent !== undefined);
+        // Detect mixed tabs/spaces
+        const hasTabs = indents.some(indent => indent.includes('\t'));
+        const hasSpaces = indents.some(indent => indent.includes(' '));
+        if (hasTabs && hasSpaces) {
+            analysis.indentationWarnings.push('Mixed tabs and spaces detected');
+        }
+        // Detect inconsistent indentation levels (spaces only)
+        if (!hasTabs && hasSpaces) {
+            const spaceCounts = indents
+                .filter(indent => indent.length > 0)
+                .map(indent => indent.length);
+            if (spaceCounts.length > 1) {
+                const gcd = spaceCounts.reduce((a, b) => {
+                    while (b !== 0) {
+                        const temp = b;
+                        b = a % b;
+                        a = temp;
+                    }
+                    return a;
+                });
+                const hasInconsistent = spaceCounts.some(count => count % gcd !== 0 && gcd > 1);
+                if (hasInconsistent) {
+                    analysis.indentationWarnings.push(`Inconsistent indentation (expected multiples of ${gcd} spaces)`);
+                }
+            }
+        }
+        // Check if edit is at a code block boundary
+        const lastLine = editedLines[editedLines.length - 1]?.trim() || '';
+        const firstLine = editedLines[0]?.trim() || '';
+        const endsWithOpenBrace = lastLine.endsWith('{') || lastLine.endsWith('(') || lastLine.endsWith('[');
+        const startsWithCloseBrace = firstLine.startsWith('}') || firstLine.startsWith(')') || firstLine.startsWith(']');
+        if (endsWithOpenBrace || startsWithCloseBrace) {
+            analysis.codeBlockBoundary = {
+                isInCompleteBlock: false,
+                suggestion: endsWithOpenBrace
+                    ? 'Edit ends with an opening bracket - ensure the closing bracket is included in a subsequent edit or already exists in the file'
+                    : 'Edit starts with a closing bracket - ensure the opening bracket exists before this edit'
+            };
+        }
+        return analysis;
+    }
+    /**
+     * Find smart context boundaries for editing
+     * Expands context to include complete code blocks when possible
+     */
+    findSmartContextBoundaries(lines, startLine, endLine, requestedContext) {
+        const totalLines = lines.length;
+        let contextStart = Math.max(1, startLine - requestedContext);
+        let contextEnd = Math.min(totalLines, endLine + requestedContext);
+        let extended = false;
+        // Try to find the start of the enclosing block
+        let bracketDepth = 0;
+        for (let i = startLine - 1; i >= Math.max(0, startLine - 50); i--) {
+            const line = lines[i];
+            if (!line)
+                continue;
+            const trimmed = line.trim();
+            // Count brackets (simple approach)
+            const openBrackets = (line.match(/\{/g) || []).length;
+            const closeBrackets = (line.match(/\}/g) || []).length;
+            bracketDepth += closeBrackets - openBrackets;
+            // If we find a function/class/block definition with balanced brackets
+            if (bracketDepth === 0 &&
+                (trimmed.match(/^(function|class|const|let|var|if|for|while|async|export)\s/i) ||
+                    trimmed.match(/=>\s*\{/) ||
+                    trimmed.match(/^\w+\s*\(/))) {
+                if (i + 1 < contextStart) {
+                    contextStart = i + 1;
+                    extended = true;
+                }
+                break;
+            }
+        }
+        // Try to find the end of the enclosing block
+        bracketDepth = 0;
+        for (let i = endLine - 1; i < Math.min(totalLines, endLine + 50); i++) {
+            const line = lines[i];
+            if (!line)
+                continue;
+            const trimmed = line.trim();
+            // Count brackets
+            const openBrackets = (line.match(/\{/g) || []).length;
+            const closeBrackets = (line.match(/\}/g) || []).length;
+            bracketDepth += openBrackets - closeBrackets;
+            // If we find a closing bracket at depth 0
+            if (bracketDepth === 0 && trimmed.startsWith('}')) {
+                if (i + 1 > contextEnd) {
+                    contextEnd = i + 1;
+                    extended = true;
+                }
+                break;
+            }
+        }
+        return { start: contextStart, end: contextEnd, extended };
+    }
     /**
      * Get the content of a file with specified line range
      * @param filePath - Path to the file (relative to base path or absolute)
@@ -206,8 +378,8 @@ export class FilesystemMCPService {
     }
     /**
      * Edit a file by replacing lines within a specified range
-     * IMPORTANT: This tool enforces small, precise edits (max 15 lines per edit) to ensure accuracy.
-     * For larger changes, make multiple sequential edits instead of one large edit.
+     * BEST PRACTICE: Keep edits small and focused (≤15 lines recommended) for better accuracy.
+     * For larger changes, make multiple parallel edits to non-overlapping sections instead of one large edit.
      *
      * @param filePath - Path to the file to edit
      * @param startLine - Starting line number (1-indexed, inclusive) - get from filesystem_read output
@@ -215,7 +387,7 @@ export class FilesystemMCPService {
      * @param newContent - New content to replace the specified lines (WITHOUT line numbers)
      * @param contextLines - Number of context lines to return before and after the edit (default: 8)
      * @returns Object containing success message, precise before/after comparison, and diagnostics
-     * @throws Error if file editing fails or if the edit range is too large
+     * @throws Error if file editing fails
      */
     async editFile(filePath, startLine, endLine, newContent, contextLines = 8) {
         try {
@@ -240,18 +412,7 @@ export class FilesystemMCPService {
             }
             // Adjust endLine if it exceeds file length
             const adjustedEndLine = Math.min(endLine, totalLines);
-            // ENFORCE SMALL EDITS: Limit to max 15 lines per edit for precision
             const linesToModify = adjustedEndLine - startLine + 1;
-            const MAX_LINES_PER_EDIT = 15;
-            if (linesToModify > MAX_LINES_PER_EDIT) {
-                throw new Error(`❌ Edit range too large (${linesToModify} lines). Maximum allowed: ${MAX_LINES_PER_EDIT} lines.\n\n` +
-                    `💡 Best Practice: Make SMALL, PRECISE edits instead of large changes.\n` +
-                    `   - Break your changes into multiple sequential edits\n` +
-                    `   - Each edit should modify at most ${MAX_LINES_PER_EDIT} lines\n` +
-                    `   - This ensures accuracy and prevents syntax errors\n\n` +
-                    `Current request: lines ${startLine}-${adjustedEndLine} (${linesToModify} lines)\n` +
-                    `Suggested approach: Split into ${Math.ceil(linesToModify / MAX_LINES_PER_EDIT)} smaller edits`);
-            }
             // Backup file before editing
             await incrementalSnapshotManager.backupFile(fullPath);
             // Extract the lines that will be replaced (for comparison)
@@ -261,9 +422,10 @@ export class FilesystemMCPService {
                 const paddedNum = String(lineNum).padStart(String(adjustedEndLine).length, ' ');
                 return `${paddedNum}→${line}`;
             }).join('\n');
-            // Calculate context range (smaller context for focused edits)
-            const contextStart = Math.max(1, startLine - contextLines);
-            const contextEnd = Math.min(totalLines, adjustedEndLine + contextLines);
+            // Calculate context range using smart boundary detection
+            const smartBoundaries = this.findSmartContextBoundaries(lines, startLine, adjustedEndLine, contextLines);
+            const contextStart = smartBoundaries.start;
+            const contextEnd = smartBoundaries.end;
             // Extract old content for context (including the lines to be replaced)
             const oldContextLines = lines.slice(contextStart - 1, contextEnd);
             const oldContent = oldContextLines.map((line, idx) => {
@@ -289,6 +451,8 @@ export class FilesystemMCPService {
             }).join('\n');
             // Write the modified content back to file
             await fs.writeFile(fullPath, modifiedLines.join('\n'), 'utf-8');
+            // Analyze code structure of the edited content
+            const structureAnalysis = this.analyzeCodeStructure(modifiedLines.join('\n'), filePath, newContentLines);
             // Try to get diagnostics from VS Code after editing
             let diagnostics = [];
             try {
@@ -302,14 +466,16 @@ export class FilesystemMCPService {
             const result = {
                 message: `✅ File edited successfully: ${filePath}\n` +
                     `   Replaced: lines ${startLine}-${adjustedEndLine} (${linesToModify} lines)\n` +
-                    `   Result: ${newContentLines.length} new lines`,
+                    `   Result: ${newContentLines.length} new lines` +
+                    (smartBoundaries.extended ? `\n   📍 Context auto-extended to show complete code block (lines ${contextStart}-${newContextEnd})` : ''),
                 oldContent,
                 newContent: newContextContent,
                 replacedLines: replacedContent,
                 contextStartLine: contextStart,
                 contextEndLine: newContextEnd,
                 totalLines: newTotalLines,
-                linesModified: linesToModify
+                linesModified: linesToModify,
+                structureAnalysis
             };
             // Add diagnostics if any were found
             if (diagnostics.length > 0) {
@@ -331,6 +497,46 @@ export class FilesystemMCPService {
                     result.message += `\n\n   ⚡ TIP: Review the errors above and make another small edit to fix them`;
                 }
             }
+            // Add structure analysis warnings to the message
+            const structureWarnings = [];
+            // Check bracket balance
+            if (!structureAnalysis.bracketBalance.curly.balanced) {
+                const diff = structureAnalysis.bracketBalance.curly.open - structureAnalysis.bracketBalance.curly.close;
+                structureWarnings.push(`Curly brackets: ${diff > 0 ? `${diff} unclosed {` : `${Math.abs(diff)} extra }`}`);
+            }
+            if (!structureAnalysis.bracketBalance.round.balanced) {
+                const diff = structureAnalysis.bracketBalance.round.open - structureAnalysis.bracketBalance.round.close;
+                structureWarnings.push(`Round brackets: ${diff > 0 ? `${diff} unclosed (` : `${Math.abs(diff)} extra )`}`);
+            }
+            if (!structureAnalysis.bracketBalance.square.balanced) {
+                const diff = structureAnalysis.bracketBalance.square.open - structureAnalysis.bracketBalance.square.close;
+                structureWarnings.push(`Square brackets: ${diff > 0 ? `${diff} unclosed [` : `${Math.abs(diff)} extra ]`}`);
+            }
+            // Check HTML tags
+            if (structureAnalysis.htmlTags && !structureAnalysis.htmlTags.balanced) {
+                if (structureAnalysis.htmlTags.unclosedTags.length > 0) {
+                    structureWarnings.push(`Unclosed HTML tags: ${structureAnalysis.htmlTags.unclosedTags.join(', ')}`);
+                }
+                if (structureAnalysis.htmlTags.unopenedTags.length > 0) {
+                    structureWarnings.push(`Unopened closing tags: ${structureAnalysis.htmlTags.unopenedTags.join(', ')}`);
+                }
+            }
+            // Check indentation
+            if (structureAnalysis.indentationWarnings.length > 0) {
+                structureWarnings.push(...structureAnalysis.indentationWarnings.map(w => `Indentation: ${w}`));
+            }
+            // Add code block boundary warnings
+            if (structureAnalysis.codeBlockBoundary && structureAnalysis.codeBlockBoundary.suggestion) {
+                structureWarnings.push(`Boundary: ${structureAnalysis.codeBlockBoundary.suggestion}`);
+            }
+            // Format structure warnings
+            if (structureWarnings.length > 0) {
+                result.message += `\n\n🔍 Structure Analysis:\n`;
+                structureWarnings.forEach(warning => {
+                    result.message += `   ⚠️  ${warning}\n`;
+                });
+                result.message += `\n   💡 TIP: These warnings help identify potential issues. If intentional (e.g., opening a block), you can ignore them.`;
+            }
             return result;
         }
         catch (error) {
@@ -451,7 +657,7 @@ export const filesystemService = new FilesystemMCPService();
 export const mcpTools = [
     {
         name: 'filesystem_read',
-        description: 'Read the content of a file within specified line range. The returned content includes line numbers (format: "lineNum→content") for precise editing. You MUST specify startLine and endLine. To read the entire file, use startLine=1 and a large endLine value (e.g., 999999). IMPORTANT: When you need to edit a file, you MUST read it first to see the exact line numbers and current content. NOTE: If the path points to a directory, this tool will automatically list its contents instead of throwing an error.',
+        description: 'Read the content of a file within specified line range. The returned content includes line numbers (format: "lineNum→content") for precise editing. You MUST specify startLine and endLine. To read the entire file, use startLine=1 and a large endLine value (e.g., 500). IMPORTANT: When you need to edit a file, you MUST read it first to see the exact line numbers and current content. NOTE: If the path points to a directory, this tool will automatically list its contents instead of throwing an error.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -524,7 +730,7 @@ export const mcpTools = [
     },
     {
         name: 'filesystem_edit',
-        description: '🎯 PREFERRED tool for precise file editing. **CRITICAL CONSTRAINTS**: (1) Maximum 15 lines per edit - larger changes will be REJECTED, (2) Must use exact line numbers from filesystem_read output. **BEST PRACTICES**: Use SMALL, INCREMENTAL edits instead of large changes. Multiple small edits are SAFER and MORE ACCURATE than one large edit. This prevents syntax errors and bracket mismatches. **WORKFLOW**: (1) Read target section with filesystem_read to get exact line numbers, (2) Edit SMALL sections (≤15 lines), (3) Verify with diagnostics, (4) Make next small edit if needed. Returns precise before/after comparison with line numbers and VS Code diagnostics.',
+        description: '🎯 PREFERRED tool for precise file editing with intelligent feedback. **BEST PRACTICES**: (1) Use SMALL, INCREMENTAL edits (recommended ≤15 lines per edit) - SAFER and MORE ACCURATE, preventing syntax errors. (2) For large changes, make MULTIPLE PARALLEL edits to different sections instead of one large edit. (3) Must use exact line numbers  Code boundaries should not be redundant or missing, such as `{}` or HTML tags causing syntax errors. **WORKFLOW**: (1) Read target section with filesystem_read, (2) Edit small sections, (3) Review auto-generated structure analysis and diagnostics, (4) Make parallel edits to non-overlapping ranges if needed. **SMART FEATURES**: Auto-detects bracket/tag mismatches, indentation issues, and code block boundaries. Context auto-extends to show complete functions/classes when detected.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -538,7 +744,7 @@ export const mcpTools = [
                 },
                 endLine: {
                     type: 'number',
-                    description: '⚠️  CRITICAL: Ending line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. Range CANNOT exceed 15 lines (endLine - startLine + 1 ≤ 15).'
+                    description: '⚠️  CRITICAL: Ending line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. 💡 TIP: Keep edits small (≤15 lines recommended) for better accuracy.'
                 },
                 newContent: {
                     type: 'string',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.8",
+	"version": "0.2.10",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {

package/readme.md

@@ -6,4 +6,57 @@
 
 ```bash
 $ npm install --global snow-ai
-```
+```
+
+## Start
+```bash
+$ snow
+```
+
+## Update
+```bash
+$ snow --update
+```
+
+## Config example  `./User/.snow/config.json`
+```json
+{
+  "openai": {
+    "baseUrl": "https://api.openai.com/v1",
+    "apiKey": "your-api-key",
+    "requestMethod": "responses",
+    "advancedModel": "gpt-5-codex",
+    "basicModel": "gpt-5-codex",
+    "maxContextTokens": 200000,
+    "compactModel": {
+      "baseUrl": "https://api.openai.com/v1",
+      "apiKey": "your-api-key",
+      "modelName": "gpt-4.1-mini"
+    }
+  }
+}
+```
+
+## Uninstall
+```bash
+$ npm uninstall --global snow-ai
+```
+
+## Install VSCode Extension
+
+* download [VSIX/snow-cli-0.2.5.vsix](https://github.com/MayDay-wpf/snow-cli/blob/main/VSIX/snow-cli-0.2.5.vsix)
+
+* open VSCode, click `Extensions` -> `Install from VSIX...` -> select `snow-cli-0.2.5.vsix`
+
+## Live View
+* **Welcome & Settings**
+
+![alt text](image.png)
+
+* **Agent**
+
+![alt text](image-1.png)
+
+* **Commands**
+
+![alt text](image-2.png)