trace.ai-cli 1.0.3 → 1.0.4

package/services/aiService.js

@@ -0,0 +1,50 @@
+const fetch = require('node-fetch');
+const { encryptData, decryptData } = require('../utils/encryption');
+
+async function processWithAI(prompt, context = '') {
+    try {
+        const models = ['kimi', 'mvrk', 'gma3', 'dsv3', 'qw32b', 'ms24b', 'll70b', 'qw3', 'mp4', 'nlm3'];
+        
+        const modelRequests = models.map(model =>
+            fetch('https://traceai.dukeindustries7.workers.dev/', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: encryptData({
+                    a: model,
+                    q: prompt,
+                    r: [],
+                    i: [],
+                    c: context
+                })
+            })
+                .then(res => res.text())
+                .then(decryptData)
+        );
+
+        const responses = await Promise.all(modelRequests);
+        const responseTexts = responses.map(r => r.text);
+
+        const finalResponse = await fetch('https://traceai.dukeindustries7.workers.dev/', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: encryptData({
+                a: 'gfinal',
+                q: prompt,
+                r: responseTexts.filter(text => text && typeof text === 'string'),
+                i: [],
+                c: context
+            })
+        });
+
+        const encryptedResult = await finalResponse.text();
+        const decryptedResult = decryptData(encryptedResult);
+        return decryptedResult.text || 'No response generated';
+    } catch (error) {
+        console.error('❌ Processing error:', error.message);
+        throw error;
+    }
+}
+
+module.exports = {
+    processWithAI
+};

package/services/fileAnalyzer.js

@@ -0,0 +1,60 @@
+const path = require('path');
+const { getFileType, readFileContent } = require('../utils/fileUtils');
+const { processWithAI } = require('./aiService');
+const { extractTextFromImage } = require('./imageService');
+
+async function analyzeFile(filePath, query = '') {
+    try {
+        const fileType = getFileType(filePath);
+        
+        if (fileType === 'image') {
+            return await extractTextFromImage(filePath);
+        }
+        
+        const content = await readFileContent(filePath);
+        const fileName = path.basename(filePath);
+        
+        let prompt;
+        if (query) {
+            prompt = `File: ${fileName} (${fileType})
+Content:
+\`\`\`
+${content}
+\`\`\`
+
+User Question: ${query}`;
+        } else {
+            if (fileType !== 'Unknown' && fileType !== 'Text' && fileType !== 'Markdown') {
+                prompt = `Analyze this ${fileType} code file (${fileName}):
+
+\`\`\`
+${content}
+\`\`\`
+
+Please provide:
+1. Code overview and purpose
+2. Key functions/components
+3. Potential issues or improvements
+4. Code quality assessment
+5. Suggestions for optimization`;
+            } else {
+                prompt = `Analyze this file content (${fileName}):
+
+\`\`\`
+${content}
+\`\`\`
+
+Please provide a summary and analysis of the content.`;
+            }
+        }
+        
+        const result = await processWithAI(prompt);
+        return { text: result || 'No response generated' }; // Ensure consistent return format
+    } catch (error) {
+        throw error;
+    }
+}
+
+module.exports = {
+    analyzeFile
+};

package/services/folderAnalyzer.js

@@ -0,0 +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
+};

package/services/imageService.js

@@ -0,0 +1,66 @@
+const fs = require('fs').promises;
+const fetch = require('node-fetch');
+const { encryptData, decryptData } = require('../utils/encryption');
+const { getMimeType } = require('../utils/fileUtils');
+
+async function convertImageToBase64(imagePath) {
+    try {
+        const imageBuffer = await fs.readFile(imagePath);
+        const base64 = imageBuffer.toString('base64');
+        const mimeType = getMimeType(imagePath);
+        return { base64, mimeType };
+    } catch (error) {
+        throw new Error(`Failed to read image: ${error.message}`);
+    }
+}
+
+async function extractTextFromImage(imagePath, question = '') {
+    try {
+        const { base64, mimeType } = await convertImageToBase64(imagePath);
+        const visionModels = ['kimi', 'mvrk', 'gma3', 'qvl72', 'llama-vision'];
+        
+        const modelRequests = visionModels.map(model =>
+            fetch('https://traceai.dukeindustries7.workers.dev/', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: encryptData({
+                    a: model,
+                    q: 'Extract and return only the text from this image. Format it naturally.',
+                    r: [],
+                    i: [{ inlineData: { data: base64, mimeType } }],
+                    c: ''
+                })
+            })
+                .then(res => res.text())
+                .then(decryptData)
+        );
+
+        const responses = await Promise.all(modelRequests);
+        const responseTexts = responses.map(r => r.text);
+
+        const finalResponse = await fetch('https://traceai.dukeindustries7.workers.dev/', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: encryptData({
+                a: 'gfinal',
+                q: question ? 
+                    `First extract and combine the text from this image, then answer this question about the extracted text: ${question}` :
+                    'Combine these extracted texts from an image into a single, coherent, and naturally formatted text. Remove duplicates and ensure clarity.',
+                r: responseTexts,
+                i: [{ inlineData: { data: base64, mimeType } }],
+                c: ''
+            })
+        });
+
+        const encryptedResult = await finalResponse.text();
+        const decryptedResult = decryptData(encryptedResult);
+        return decryptedResult.text || 'Unable to analyze image'
+    } catch (error) {
+        console.error('❌ Error analyzing image:', error);
+        throw error;
+    }
+}
+
+module.exports = {
+    extractTextFromImage
+};

package/utils/encryption.js

@@ -0,0 +1,29 @@
+const ENCRYPTION_KEY = 'AlzaSyCVKlzUxK';
+
+function encodeUnicode(str) {
+    const utf8Bytes = new TextEncoder().encode(str);
+    const base64 = Buffer.from(utf8Bytes).toString('base64');
+    return base64;
+}
+
+function decodeUnicode(str) {
+    const bytes = Buffer.from(str, 'base64');
+    return new TextDecoder().decode(bytes);
+}
+
+function encryptData(data) {
+    const jsonStr = JSON.stringify(data);
+    const encoded = encodeUnicode(jsonStr);
+    return encoded.split('').reverse().join('');
+}
+
+function decryptData(encoded) {
+    const reversed = encoded.split('').reverse().join('');
+    const decoded = decodeUnicode(reversed);
+    return JSON.parse(decoded);
+}
+
+module.exports = {
+    encryptData,
+    decryptData
+};

package/utils/fileUtils.js

@@ -0,0 +1,101 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+// File type detection
+function getFileType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const codeExtensions = {
+        '.js': 'JavaScript',
+        '.jsx': 'React/JavaScript',
+        '.ts': 'TypeScript',
+        '.tsx': 'React/TypeScript',
+        '.py': 'Python',
+        '.java': 'Java',
+        '.cpp': 'C++',
+        '.c': 'C',
+        '.cs': 'C#',
+        '.php': 'PHP',
+        '.rb': 'Ruby',
+        '.go': 'Go',
+        '.rs': 'Rust',
+        '.swift': 'Swift',
+        '.kt': 'Kotlin',
+        '.scala': 'Scala',
+        '.html': 'HTML',
+        '.css': 'CSS',
+        '.scss': 'SCSS',
+        '.sass': 'SASS',
+        '.less': 'LESS',
+        '.vue': 'Vue.js',
+        '.svelte': 'Svelte',
+        '.json': 'JSON',
+        '.xml': 'XML',
+        '.yaml': 'YAML',
+        '.yml': 'YAML',
+        '.toml': 'TOML',
+        '.ini': 'INI',
+        '.conf': 'Config',
+        '.md': 'Markdown',
+        '.txt': 'Text',
+        '.sql': 'SQL',
+        '.sh': 'Shell Script',
+        '.bash': 'Bash Script',
+        '.zsh': 'Zsh Script',
+        '.ps1': 'PowerShell',
+        '.bat': 'Batch Script',
+        '.dockerfile': 'Dockerfile',
+        '.gitignore': 'Git Ignore',
+        '.env': 'Environment Variables'
+    };
+    
+    const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.svg'];
+    
+    if (imageExtensions.includes(ext)) {
+        return 'image';
+    }
+    
+    return codeExtensions[ext] || 'Unknown';
+}
+
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.bmp': 'image/bmp',
+        '.svg': 'image/svg+xml'
+    };
+    return mimeTypes[ext] || 'image/jpeg';
+}
+
+// File reading and processing
+async function readFileContent(filePath) {
+    try {
+        const stats = await fs.stat(filePath);
+        if (stats.isDirectory()) {
+            throw new Error('Path is a directory, not a file');
+        }
+        
+        // Check file size (limit to 1MB for safety)
+        if (stats.size > 1024 * 1024) {
+            throw new Error('File too large. Maximum size is 1MB');
+        }
+        
+        const content = await fs.readFile(filePath, 'utf8');
+        return content;
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        throw error;
+    }
+}
+
+module.exports = {
+    getFileType,
+    getMimeType,
+    readFileContent
+};