trace.ai-cli 1.1.8 → 1.2.0

package/services/fileAnalyzer.js

@@ -1,16 +1,91 @@
 const path = require('path');
+const fs = require('fs').promises;
+const pdfParse = require('pdf-parse');
 const { getFileType, readFileContent } = require('../utils/fileUtils');
 const { processWithAI } = require('./aiService');
 const { extractTextFromImage } = require('./imageService');
 
-async function analyzeFile(filePath, query = '') {
+async function analyzeFile(filePath, query = '', mode = 2) {
     try {
         const fileType = getFileType(filePath);
         
+        // Handle images - use vision API only for images
         if (fileType === 'image') {
-            return await extractTextFromImage(filePath);
+            const result = await extractTextFromImage(filePath, query, mode);
+            return { text: result };
         }
         
+        // Handle documents (PDFs, Word, etc.)
+        if (fileType === 'document') {
+            const fileName = path.basename(filePath);
+            const ext = path.extname(filePath).toLowerCase();
+            
+            // Extract text from PDF
+            if (ext === '.pdf') {
+                try {
+                    const dataBuffer = await fs.readFile(filePath);
+                    const pdfData = await pdfParse(dataBuffer);
+                    const content = pdfData.text;
+                    
+                    if (!content || content.trim().length === 0) {
+                        return {
+                            text: `❌ **Unable to Extract Text from PDF**\n\n` +
+                                  `The PDF "${fileName}" appears to be empty or contains only images/scanned content.\n\n` +
+                                  `**Try using the /image command for scanned PDFs:**\n` +
+                                  `\`/image "${filePath}" ${query || 'analyze this document'}\``
+                        };
+                    }
+                    
+                    // Build prompt for AI analysis
+                    let prompt;
+                    if (query) {
+                        prompt = `PDF Document: ${fileName}
+Content:
+\`\`\`
+${content}
+\`\`\`
+
+User Question: ${query}`;
+                    } else {
+                        prompt = `Analyze this PDF document (${fileName}):
+
+\`\`\`
+${content}
+\`\`\`
+
+Please provide a comprehensive summary and analysis of the document.`;
+                    }
+                    
+                    const result = await processWithAI(prompt, '', mode);
+                    return { text: result || 'No response generated' };
+                    
+                } catch (pdfError) {
+                    return {
+                        text: `❌ **Error Reading PDF**\n\n` +
+                              `Failed to extract text from "${fileName}": ${pdfError.message}\n\n` +
+                              `**Possible reasons:**\n` +
+                              `- The PDF is corrupted or password-protected\n` +
+                              `- The PDF contains only images (scanned document)\n\n` +
+                              `**Try using /image command for scanned PDFs:**\n` +
+                              `\`/image "${filePath}" ${query || 'analyze this document'}\``
+                    };
+                }
+            }
+            
+            // For other document types (Word, Excel, etc.)
+            return { 
+                text: `❌ **Document Type Not Supported**\n\n` +
+                      `The file "${fileName}" is a ${ext.toUpperCase()} document.\n\n` +
+                      `**Supported formats:**\n` +
+                      `- PDF files (.pdf) - Text extraction supported\n` +
+                      `- Text files (.txt, .md, etc.)\n` +
+                      `- Code files (.js, .py, .java, etc.)\n\n` +
+                      `**For ${ext.toUpperCase()} files:**\n` +
+                      `Please convert to PDF or text format first.`
+            };
+        }
+        
+        // Handle text-based files
         const content = await readFileContent(filePath);
         const fileName = path.basename(filePath);
         
@@ -48,8 +123,8 @@ Please provide a summary and analysis of the content.`;
             }
         }
         
-        const result = await processWithAI(prompt);
-        return { text: result || 'No response generated' }; // Ensure consistent return format
+        const result = await processWithAI(prompt, '', mode);
+        return { text: result || 'No response generated' };
     } catch (error) {
         throw error;
     }
@@ -57,4 +132,4 @@ Please provide a summary and analysis of the content.`;
 
 module.exports = {
     analyzeFile
-};
+};

package/services/folderAnalyzer.js

@@ -1,164 +1,164 @@
-const fs = require('fs').promises;
-const path = require('path');
-const { getFileType } = require('../utils/fileUtils');
-const { processWithAI } = require('./aiService');
-
-function buildSimpleFileTree(folderPath, items, statsCache, depth = 0) {
-    let tree = '';
-    const indent = '  '.repeat(depth);
-    
-    for (const item of items) {
-        const itemPath = path.join(folderPath, item);
-        const stats = statsCache.get(itemPath);
-        tree += `${indent}${item}${stats.isDirectory() ? '/' : ''}\n`;
-        
-        if (stats.isDirectory()) {
-            try {
-                const subItems = fs.readdirSync(itemPath);
-                const subStatsCache = new Map();
-                for (const subItem of subItems) {
-                    const subItemPath = path.join(itemPath, subItem);
-                    subStatsCache.set(subItemPath, fs.statSync(subItemPath));
-                }
-                tree += buildSimpleFileTree(itemPath, subItems, subStatsCache, depth + 1);
-            } catch (error) {
-                tree += `${indent}  (error accessing directory)\n`;
-            }
-        }
-    }
-    
-    return tree;
-}
-
-async function analyzeFolder(folderPath, maxDepth = 2, currentDepth = 0) {
-    try {
-        const stats = await fs.stat(folderPath);
-        if (!stats.isDirectory()) {
-            throw new Error('Path is not a directory');
-        }
-        
-        const analysis = {
-            path: folderPath,
-            files: [],
-            folders: [],
-            fileTree: '', // Store simple file tree
-            summary: {
-                totalFiles: 0,
-                totalFolders: 0,
-                fileTypes: {},
-                languages: {},
-                size: 0
-            }
-        };
-        
-        const items = await fs.readdir(folderPath);
-        const statsCache = new Map();
-        
-        // Cache stats for all items
-        for (const item of items) {
-            const itemPath = path.join(folderPath, item);
-            statsCache.set(itemPath, await fs.stat(itemPath));
-        }
-        
-        // Build simple file tree
-        analysis.fileTree = buildSimpleFileTree(folderPath, items, statsCache);
-        
-        for (const item of items) {
-            const itemPath = path.join(folderPath, item);
-            const itemStats = statsCache.get(itemPath);
-            
-            if (itemStats.isDirectory()) {
-                analysis.folders.push(item);
-                analysis.summary.totalFolders++;
-                
-                if (currentDepth < maxDepth) {
-                    try {
-                        const subAnalysis = await analyzeFolder(itemPath, maxDepth, currentDepth + 1);
-                        analysis.summary.totalFiles += subAnalysis.summary.totalFiles;
-                        analysis.summary.totalFolders += subAnalysis.summary.totalFolders;
-                        analysis.summary.size += subAnalysis.summary.size;
-                        
-                        Object.keys(subAnalysis.summary.fileTypes).forEach(type => {
-                            analysis.summary.fileTypes[type] = (analysis.summary.fileTypes[type] || 0) + subAnalysis.summary.fileTypes[type];
-                        });
-                        Object.keys(subAnalysis.summary.languages).forEach(lang => {
-                            analysis.summary.languages[lang] = (analysis.summary.languages[lang] || 0) + subAnalysis.summary.languages[lang];
-                        });
-                    } catch (error) {
-                        console.warn(`Warning: Cannot access folder ${itemPath}`);
-                    }
-                }
-            } else {
-                const fileType = getFileType(itemPath);
-                analysis.files.push({
-                    name: item,
-                    type: fileType,
-                    size: itemStats.size,
-                    modified: itemStats.mtime
-                });
-                
-                analysis.summary.totalFiles++;
-                analysis.summary.size += itemStats.size;
-                analysis.summary.fileTypes[fileType] = (analysis.summary.fileTypes[fileType] || 0) + 1;
-                
-                if (fileType !== 'image' && fileType !== 'Unknown') {
-                    analysis.summary.languages[fileType] = (analysis.summary.languages[fileType] || 0) + 1;
-                }
-            }
-        }
-        
-        return analysis;
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new Error(`Folder not found: ${folderPath}`);
-        }
-        if (error.code === 'EACCES') {
-            throw new Error(`Access denied: ${folderPath}`);
-        }
-        throw error;
-    }
-}
-
-async function analyzeFolderStructure(folderPath, query = '') {
-    try {
-        const analysis = await analyzeFolder(folderPath);
-        
-        const structureText = `
-Folder: ${analysis.path}
-Files: ${analysis.summary.totalFiles}
-Folders: ${analysis.summary.totalFolders}
-Total Size: ${(analysis.summary.size / 1024).toFixed(2)} KB
-
-Files and Directories:
-${analysis.fileTree}
-
-File Types:
-${Object.entries(analysis.summary.fileTypes).map(([type, count]) => `- ${type}: ${count}`).join('\n')}
-
-Languages/Technologies:
-${Object.entries(analysis.summary.languages).map(([lang, count]) => `- ${lang}: ${count} files`).join('\n')}
-`;
-
-        let prompt;
-        if (query) {
-            prompt = `Project Structure:
-${structureText}
-
-User Question: ${query}`;
-        } else {
-            prompt = `Analyze this project structure:
-${structureText}
-
-Provide a brief overview of the project based on its file structure.`;
-        }
-        
-        const result = await processWithAI(prompt);
-        return { text: result || 'No response generated' }; // Ensure text property is always defined
-    } catch (error) {
-        throw error;
-    }
-}
-
-module.exports = {
-    analyzeFolderStructure
+const fs = require('fs').promises;
+const path = require('path');
+const { getFileType } = require('../utils/fileUtils');
+const { processWithAI } = require('./aiService');
+
+function buildSimpleFileTree(folderPath, items, statsCache, depth = 0) {
+    let tree = '';
+    const indent = '  '.repeat(depth);
+    
+    for (const item of items) {
+        const itemPath = path.join(folderPath, item);
+        const stats = statsCache.get(itemPath);
+        tree += `${indent}${item}${stats.isDirectory() ? '/' : ''}\n`;
+        
+        if (stats.isDirectory()) {
+            try {
+                const subItems = fs.readdirSync(itemPath);
+                const subStatsCache = new Map();
+                for (const subItem of subItems) {
+                    const subItemPath = path.join(itemPath, subItem);
+                    subStatsCache.set(subItemPath, fs.statSync(subItemPath));
+                }
+                tree += buildSimpleFileTree(itemPath, subItems, subStatsCache, depth + 1);
+            } catch (error) {
+                tree += `${indent}  (error accessing directory)\n`;
+            }
+        }
+    }
+    
+    return tree;
+}
+
+async function analyzeFolder(folderPath, maxDepth = 2, currentDepth = 0) {
+    try {
+        const stats = await fs.stat(folderPath);
+        if (!stats.isDirectory()) {
+            throw new Error('Path is not a directory');
+        }
+        
+        const analysis = {
+            path: folderPath,
+            files: [],
+            folders: [],
+            fileTree: '', // Store simple file tree
+            summary: {
+                totalFiles: 0,
+                totalFolders: 0,
+                fileTypes: {},
+                languages: {},
+                size: 0
+            }
+        };
+        
+        const items = await fs.readdir(folderPath);
+        const statsCache = new Map();
+        
+        // Cache stats for all items
+        for (const item of items) {
+            const itemPath = path.join(folderPath, item);
+            statsCache.set(itemPath, await fs.stat(itemPath));
+        }
+        
+        // Build simple file tree
+        analysis.fileTree = buildSimpleFileTree(folderPath, items, statsCache);
+        
+        for (const item of items) {
+            const itemPath = path.join(folderPath, item);
+            const itemStats = statsCache.get(itemPath);
+            
+            if (itemStats.isDirectory()) {
+                analysis.folders.push(item);
+                analysis.summary.totalFolders++;
+                
+                if (currentDepth < maxDepth) {
+                    try {
+                        const subAnalysis = await analyzeFolder(itemPath, maxDepth, currentDepth + 1);
+                        analysis.summary.totalFiles += subAnalysis.summary.totalFiles;
+                        analysis.summary.totalFolders += subAnalysis.summary.totalFolders;
+                        analysis.summary.size += subAnalysis.summary.size;
+                        
+                        Object.keys(subAnalysis.summary.fileTypes).forEach(type => {
+                            analysis.summary.fileTypes[type] = (analysis.summary.fileTypes[type] || 0) + subAnalysis.summary.fileTypes[type];
+                        });
+                        Object.keys(subAnalysis.summary.languages).forEach(lang => {
+                            analysis.summary.languages[lang] = (analysis.summary.languages[lang] || 0) + subAnalysis.summary.languages[lang];
+                        });
+                    } catch (error) {
+                        console.warn(`Warning: Cannot access folder ${itemPath}`);
+                    }
+                }
+            } else {
+                const fileType = getFileType(itemPath);
+                analysis.files.push({
+                    name: item,
+                    type: fileType,
+                    size: itemStats.size,
+                    modified: itemStats.mtime
+                });
+                
+                analysis.summary.totalFiles++;
+                analysis.summary.size += itemStats.size;
+                analysis.summary.fileTypes[fileType] = (analysis.summary.fileTypes[fileType] || 0) + 1;
+                
+                if (fileType !== 'image' && fileType !== 'Unknown') {
+                    analysis.summary.languages[fileType] = (analysis.summary.languages[fileType] || 0) + 1;
+                }
+            }
+        }
+        
+        return analysis;
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Folder not found: ${folderPath}`);
+        }
+        if (error.code === 'EACCES') {
+            throw new Error(`Access denied: ${folderPath}`);
+        }
+        throw error;
+    }
+}
+
+async function analyzeFolderStructure(folderPath, query = '') {
+    try {
+        const analysis = await analyzeFolder(folderPath);
+        
+        const structureText = `
+Folder: ${analysis.path}
+Files: ${analysis.summary.totalFiles}
+Folders: ${analysis.summary.totalFolders}
+Total Size: ${(analysis.summary.size / 1024).toFixed(2)} KB
+
+Files and Directories:
+${analysis.fileTree}
+
+File Types:
+${Object.entries(analysis.summary.fileTypes).map(([type, count]) => `- ${type}: ${count}`).join('\n')}
+
+Languages/Technologies:
+${Object.entries(analysis.summary.languages).map(([lang, count]) => `- ${lang}: ${count} files`).join('\n')}
+`;
+
+        let prompt;
+        if (query) {
+            prompt = `Project Structure:
+${structureText}
+
+User Question: ${query}`;
+        } else {
+            prompt = `Analyze this project structure:
+${structureText}
+
+Provide a brief overview of the project based on its file structure.`;
+        }
+        
+        const result = await processWithAI(prompt);
+        return { text: result || 'No response generated' }; // Ensure text property is always defined
+    } catch (error) {
+        throw error;
+    }
+}
+
+module.exports = {
+    analyzeFolderStructure
 };

package/services/imageService.js

@@ -3,6 +3,20 @@ const fetch = require('node-fetch');
 const { encryptData, decryptData } = require('../utils/encryption');
 const { getMimeType } = require('../utils/fileUtils');
 
+// Model selection helper for vision models
+function getVisionModels(mode) {
+    switch (Number(mode)) {
+        case 1: // Fast
+            return ['g1'];
+        case 2: // Balanced
+            return ['qvl72', 'mvrk'];
+        case 3: // Think
+            return ['g1', 'mvrk', 'gma3', 'qvl72', 'sct'];
+        default:
+            return ['qvl72', 'mvrk'];
+    }
+}
+
 async function convertImageToBase64(imagePath) {
     try {
         const imageBuffer = await fs.readFile(imagePath);
@@ -14,10 +28,10 @@ async function convertImageToBase64(imagePath) {
     }
 }
 
-async function extractTextFromImage(imagePath, question = '') {
+async function extractTextFromImage(imagePath, question = '', mode = 2) {
     try {
         const { base64, mimeType } = await convertImageToBase64(imagePath);
-        const visionModels = ['kimi', 'mvrk', 'gma3', 'qvl72', 'llama-vision'];
+        const visionModels = getVisionModels(mode); // Use selected mode
         
         const modelRequests = visionModels.map(model =>
             fetch('https://traceai.dukeindustries7.workers.dev/', {