trace.ai-cli 1.0.0

package/index.js

@@ -0,0 +1,740 @@
+#!/usr/bin/env node
+
+const fs = require('fs').promises;
+const path = require('path');
+const readline = require('readline');
+const fetch = require('node-fetch');
+
+// 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() {
+        console.log('🚀 Welcome to Trace.Ai CLI - Enhanced File & Code Analysis!');
+        console.log('\nCommands:');
+        console.log('  /file "path" question     - Analyze a file with optional question');
+        console.log('  /folder "path" question   - Analyze a folder structure with optional question');
+        console.log('  /image "path"               - Analyze a image');
+        console.log('  /context <text>             - Set text context for conversations');
+        console.log('  /context-file "path"        - Add file context');
+        console.log('  /view-context               - View all contexts');
+        console.log('  /clear [text|file "path"]   - Clear specific or all contexts');
+        console.log('  /exit                       - Exit the application');
+        console.log('  Or just type your question directly\n');
+
+        console.log('💡 Examples:');
+        console.log('  /file app.js                - General code analysis');
+        console.log('  /file app.js explain this code in simple terms');
+        console.log('  /file app.js find bugs and security issues');
+        console.log('  /folder ./project           - Project structure overview');
+        console.log('  /folder ./src what is the main architecture pattern?\n');
+
+        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();
+    }
+}
+
+// Handle CLI arguments
+async function handleCliArgs() {
+    const args = process.argv.slice(2);
+    
+    if (args.length === 0) {
+        const traceAI = new TraceAI();
+        await traceAI.start();
+        return;
+    }
+
+    const command = args[0];
+    
+    if (command === 'file' && args[1]) {
+        const filePath = args[1];
+        const query = args.slice(2).join(' ');
+        
+        try {
+            console.log('📄 Analyzing file...');
+            const result = await analyzeFile(filePath, query);
+            console.log('\n📄 File Analysis:');
+            console.log('=' .repeat(50));
+            console.log(result);
+            console.log('=' .repeat(50));
+        } catch (error) {
+            console.error('❌ Error:', error.message);
+            process.exit(1);
+        }
+    } else if (command === 'folder' && args[1]) {
+        const folderPath = args[1];
+        const query = args.slice(2).join(' ');
+        
+        try {
+            console.log('📁 Analyzing folder...');
+            const result = await analyzeFolderStructure(folderPath, query);
+            console.log('\n📁 Folder Analysis:');
+            console.log('=' .repeat(50));
+            console.log(result);
+            console.log('=' .repeat(50));
+        } catch (error) {
+            console.error('❌ Error:', error.message);
+            process.exit(1);
+        }
+    } else if (command === 'image' && args[1]) {
+        try {
+            const imagePath = args[1];
+            const question = args.slice(2).join(' ');
+            console.log('🖼️ Analysing Image...');
+            const result = await extractTextFromImage(imagePath, question);
+            console.log('\n🖼️ Image Analysis:');
+            console.log('=' .repeat(50));
+            console.log(result);
+            console.log('=' .repeat(50));
+        } catch (error) {
+            console.error('❌ Error:', error.message);
+            process.exit(1);
+        }
+    } else if (command === 'ask') {
+        const query = args.slice(1).join(' ');
+        if (!query) {
+            console.error('❌ Please provide a question after "ask"');
+            process.exit(1);
+        }
+        
+        try {
+            console.log('Processing your question...');
+            const result = await processWithAI(query);
+            console.log('\nTrace.Ai Response:');
+            console.log('=' .repeat(50));
+            console.log(result);
+            console.log('=' .repeat(50));
+        } catch (error) {
+            console.error('❌ Error:', error.message);
+            if (error.code === 'ENOENT') {
+                console.error('File not found. Please check the path and try again.');
+            }
+            process.exit(1);
+        }
+    } else {
+        console.log('Trace.Ai - AI powered CLI tool ');
+        console.log('\nUsage:');
+        console.log('  trace-ai                              - Start interactive mode');
+        console.log('  trace-ai file "path" question       - Analyze a file');
+        console.log('  trace-ai folder "path" question     - Analyze a folder');
+        console.log('  trace-ai image "path"                 - Analyze a image');
+        console.log('  trace-ai ask question               - Ask a question');
+        console.log('\nExamples:');
+        console.log('  trace-ai file ./app.js');
+        console.log('  trace-ai file ./app.js explain this code"');
+        console.log('  trace-ai file ./app.js find security vulnerabilities');
+        console.log('  trace-ai folder ./project');
+        console.log('  trace-ai folder ./src what is the architecture?');
+        console.log('  trace-ai image screenshot.png');
+        console.log('  trace-ai ask Explain quantum computing');
+    }
+}
+
+// Error handling
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('❌ Unhandled Rejection at:', promise, 'reason:', reason);
+});
+
+process.on('uncaughtException', (error) => {
+    console.error('❌ Uncaught Exception:', error);
+    process.exit(1);
+});
+
+// Start the application
+if (require.main === module) {
+    handleCliArgs().catch(console.error);
+}
+
+module.exports = { TraceAI, processWithAI, extractTextFromImage, analyzeFile, analyzeFolderStructure };

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "trace.ai-cli",
+    "version": "1.0.0",
+    "description": "A powerful AI-powered CLI tool",
+    "main": "index.js",
+    "bin": {
+        "trace-ai": "index.js"
+    },
+    "scripts": {
+        "start": "node index.js",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [
+        "ai",
+        "cli",
+        "code-analysis",
+        "file-analysis",
+        "code-review",
+        "bug-detection",
+        "text-processing",
+        "image-text-extraction",
+        "ocr",
+        "artificial-intelligence",
+        "command-line",
+        "tool",
+        "developer-tools",
+        "code-quality",
+        "project-analysis"
+    ],
+    "author": "Dukeindustries7",
+    "license": "MIT",
+    "dependencies": {
+        "node-fetch": "^2.6.7"
+    },
+    "engines": {
+        "node": ">=14.0.0"
+    },
+    "homepage": "https://github.com/yourusername/trace-ai-cli#readme"
+}