trace.ai-cli 1.0.3 → 1.0.4

package/index.js

@@ -1,644 +1,10 @@
 #!/usr/bin/env node
 
-const fs = require('fs').promises;
-const path = require('path');
-const readline = require('readline');
-const fetch = require('node-fetch');
-const figlet = require('figlet');
-const chalk = require('chalk');
-
-// Core encryption/decryption logic from background.js
-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);
-}
-
-// 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;
-    }
-}
-
-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;
-    }
-}
-
-// Image processing functions
-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 {
-        console.log('Processing...');
-        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 || 'No text extracted from image'
-    } catch (error) {
-        console.error('❌ Error extracting text from image:', error);
-        throw error;
-    }
-}
-
-async function processWithAI(prompt, context = '') {
-    try {
-        console.log('Processing...');
-        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;
-    }
-}
-
-// File and folder analysis functions
-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;
-    }
-}
-
-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;
-    }
-}
-// CLI Interface
-class TraceAI {
-    constructor() {
-        this.rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        this.contexts = {
-            text: '',
-            files: new Map()
-        };
-    }
-
-    async start() {
-        // Create ASCII art for "Trace.A"
-        const asciiArt = figlet.textSync('Trace.Ai', {
-            font: 'Big',
-            horizontalLayout: 'default',
-            verticalLayout: 'default'
-        });
-        
-        console.log(chalk.cyan(asciiArt));
-        console.log(chalk.gray('═'.repeat(60)));
-        console.log(chalk.bold.green('Welcome to Trace.Ai CLI - AI powered CLI tool!'));
-        console.log(chalk.gray('═'.repeat(60)));
-        
-        console.log(chalk.bold.yellow('\n📋 Commands:'));
-        console.log(chalk.magenta('  /file "path" question     ') + chalk.gray('- Analyze a file with optional question'));
-        console.log(chalk.magenta('  /folder "path" question   ') + chalk.gray('- Analyze a folder structure with optional question'));
-        console.log(chalk.magenta('  /image "path" question           ') + chalk.gray('- Analyze an image'));
-        console.log(chalk.magenta('  /context <text>           ') + chalk.gray('- Set text context for conversations'));
-        console.log(chalk.magenta('  /context-file "path"      ') + chalk.gray('- Add file context'));
-        console.log(chalk.magenta('  /view-context             ') + chalk.gray('- View all contexts'));
-        console.log(chalk.magenta('  /clear [text|file "path"] ') + chalk.gray('- Clear specific or all contexts'));
-        console.log(chalk.magenta('  /exit                     ') + chalk.gray('- Exit the application'));
-        console.log(chalk.magenta('  Or just type your question directly'));
-    
-        console.log(chalk.bold.blue('\n💡 Examples:'));
-        console.log(chalk.magenta('  /file "path/app.js" ') + chalk.italic('explain this code in simple terms'));
-        console.log(chalk.magenta('  /image "path/image.png" ') + chalk.italic('what is this image about?'));
-        console.log(chalk.magenta('  /folder "path/src" ') + chalk.italic('what is the purpose of this project?'));    
-        console.log(chalk.gray('\n' + '─'.repeat(60)));
-        console.log(chalk.green('Ready to assist! Type your command or question below:'));
-        console.log();
-    
-        this.promptUser();
-    }
-
-    promptUser() {
-        this.rl.question('Trace.Ai> ', async (input) => {
-            await this.handleInput(input.trim());
-            this.promptUser();
-        });
-    }
-
-    async handleInput(input) {
-        if (!input) return;
-    
-        try {
-            if (input.startsWith('/file ')) {
-                await this.handleFileCommand(input.substring(6).trim());
-            } else if (input.startsWith('/folder ')) {
-                await this.handleFolderCommand(input.substring(8).trim());
-            } else if (input.startsWith('/image ')) {
-                const parts = input.substring(7).trim().match(/(?:"[^"]*"|[^\s"]+)+/g) || [];
-                const imagePath = parts[0]?.replace(/\\/g, '').replace(/^"|"$/g, '');
-                const question = parts.slice(1).join(' ').replace(/^"|"$/g, '');
-                await this.handleImageCommand(imagePath, question);
-            } else if (input.startsWith('/context ')) {
-                const context = input.substring(9).trim();
-                this.contexts.text = context;
-                console.log('✅ Text context set successfully');
-            } else if (input.startsWith('/context-file ')) {
-                const filePath = input.substring(13).trim().replace(/\\/g, '').replace(/^"|"$/g, '');
-                try {
-                    const fileContent = await fs.readFile(filePath, 'utf8');
-                    this.contexts.files.set(filePath, fileContent);
-                    console.log(`✅ File context added: ${filePath}`);
-                } catch (error) {
-                    console.error(`❌ Error reading file: ${error.message}`);
-                }
-            } else if (input === '/view-context') {
-                console.log('\nCurrent Contexts:');
-                console.log('Text Context:', this.contexts.text || '(none)');
-                console.log('\nFile Contexts:');
-                if (this.contexts.files.size === 0) {
-                    console.log('(none)');
-                } else {
-                    for (const [path] of this.contexts.files) {
-                        console.log(`- ${path}`);
-                    }
-                }
-            } else if (input.startsWith('/clear')) {
-                const parts = input.match(/(?:"[^"]*"|[^\s"]+)+/g) || [];
-                if (parts.length === 1) {
-                    this.contexts.text = '';
-                    this.contexts.files.clear();
-                    console.log('✅ All contexts cleared');
-                } else if (parts[1] === 'text') {
-                    this.contexts.text = '';
-                    console.log('✅ Text context cleared');
-                } else if (parts[1] === 'file' && parts[2]) {
-                    const filePath = parts[2].replace(/\\/g, '').replace(/^"|"$/g, '');
-                    if (this.contexts.files.delete(filePath)) {
-                        console.log(`✅ File context cleared: ${filePath}`);
-                    } else {
-                        console.log(`❌ No such file context: ${filePath}`);
-                    }
-                } else {
-                    console.log('❌ Invalid clear command. Use: /clear [text|file <path>]');
-                }
-            } else if (input === '/exit') {
-                console.log('👋 Goodbye!');
-                process.exit(0);
-            } else {
-                await this.handleTextQuery(input);
-            }
-        } catch (error) {
-            console.error('❌ Error:', error.message);
-        }
-    }
-
-    async handleFileCommand(input) {
-        // Use regex to split input, preserving quoted strings
-        const parts = input.match(/(?:"[^"]*"|[^\s"]+)+/g) || [];
-        const filePath = parts[0]?.replace(/\\/g, '').replace(/^"|"$/g, '');
-        const query = parts.slice(1).join(' ').replace(/^"|"$/g, '');
-        
-        if (!filePath) {
-            console.error('❌ Error: No file path provided');
-            return;
-        }
-        
-        try {
-            const result = await analyzeFile(filePath, query);
-            console.log('\n📄 File Analysis:');
-            console.log('=' .repeat(50));
-            console.log(result.text || result); // Handle both object and string responses
-            console.log('=' .repeat(50) + '\n');
-        } catch (error) {
-            console.error('❌ Error analyzing file:', error.message);
-        }
-    }
-
-    async handleFolderCommand(input) {
-        const parts = input.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/);
-        const folderPath = parts[0].replace(/\\/g, '').replace(/^"|"$/g, '');
-        const query = parts.slice(1).join(' ').replace(/^"|"$/g, '');
-        
-        try {
-            const result = await analyzeFolderStructure(folderPath, query);
-            console.log('\n📁 Folder Analysis:');
-            console.log('=' .repeat(50));
-            console.log(result.text);
-            console.log('=' .repeat(50) + '\n');
-        } catch (error) {
-            console.error('❌ Error analyzing folder:', error.message);
-        }
-    }
-
-    async handleImageCommand(imagePath, question = '') {
-        try {
-            await fs.access(imagePath);
-            const result = await extractTextFromImage(imagePath, question);
-            console.log('\n🖼️ Image Analysis:');
-            console.log('=' .repeat(50));
-            console.log(result);
-            console.log('=' .repeat(50) + '\n');
-        } catch (error) {
-            if (error.code === 'ENOENT') {
-                console.error('❌ Image file not found:', imagePath);
-            } else {
-                console.error('❌ Error processing image:', error.message);
-            }
-        }
-    }
-
-    async handleTextQuery(query) {
-        try {
-            let combinedContext = this.contexts.text;
-            if (this.contexts.files.size > 0) {
-                combinedContext += '\n\nFile Contexts:\n';
-                for (const [path, content] of this.contexts.files) {
-                    combinedContext += `\nFile: ${path}\n${content}\n`;
-                }
-            }
-            const result = await processWithAI(query, combinedContext);
-            console.log('\nTrace.Ai Response:');
-            console.log('=' .repeat(50));
-            console.log(result);
-            console.log('=' .repeat(50) + '\n');
-        } catch (error) {
-            console.error('❌ Error processing query:', error.message);
-        }
-    }
-
-    close() {
-        this.rl.close();
-    }
-}
+const TraceAI = require('./cli/traceAI');
+const { analyzeFile } = require('./services/fileAnalyzer');
+const { analyzeFolderStructure } = require('./services/folderAnalyzer');
+const { extractTextFromImage } = require('./services/imageService');
+const { processWithAI } = require('./services/aiService');
 
 // Handle CLI arguments
 async function handleCliArgs() {
@@ -661,7 +27,7 @@ async function handleCliArgs() {
             const result = await analyzeFile(filePath, query);
             console.log('\n📄 File Analysis:');
             console.log('=' .repeat(50));
-            console.log(result);
+            console.log(result.text || result);
             console.log('=' .repeat(50));
         } catch (error) {
             console.error('❌ Error:', error.message);
@@ -676,7 +42,7 @@ async function handleCliArgs() {
             const result = await analyzeFolderStructure(folderPath, query);
             console.log('\n📁 Folder Analysis:');
             console.log('=' .repeat(50));
-            console.log(result);
+            console.log(result.text);
             console.log('=' .repeat(50));
         } catch (error) {
             console.error('❌ Error:', error.message);
@@ -751,4 +117,10 @@ if (require.main === module) {
     handleCliArgs().catch(console.error);
 }
 
-module.exports = { TraceAI, processWithAI, extractTextFromImage, analyzeFile, analyzeFolderStructure };
+module.exports = { 
+    TraceAI, 
+    processWithAI, 
+    extractTextFromImage, 
+    analyzeFile, 
+    analyzeFolderStructure 
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "trace.ai-cli",
-    "version": "1.0.3",
+    "version": "1.0.4",
     "description": "A powerful AI-powered CLI tool",
     "main": "index.js",
     "bin": {