minovative-mind-cli 2.1.1 → 2.1.2

package/README.md

@@ -15,6 +15,9 @@ the build/performance metrics are green.
 [![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
 [![Version](https://img.shields.io/npm/v/minovative-mind-cli.svg)](https://npmjs.org/package/minovative-mind-cli)
 [![Downloads/week](https://img.shields.io/npm/dw/minovative-mind-cli.svg)](https://npmjs.org/package/minovative-mind-cli)
+[![Node.js Version](https://img.shields.io/node/v/minovative-mind-cli.svg)](https://nodejs.org)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![License](https://img.shields.io/npm/l/minovative-mind-cli.svg)](https://github.com/quarantiine/minovative-mind-cli/blob/main/LICENSE.md)
 
 - Official Website: [Main Website](https://www.minovativemind.dev/)
 - Latest Updates: [Updates](https://www.minovativemind.dev/updates)

package/dist/services/agent-tools.js

@@ -361,7 +361,147 @@ export async function readFile(workspaceRoot, filePath, startLine, endLine, targ
                 inlineData: { mimeType: 'application/pdf', data: base64Data },
             };
         }
+        // Prevent reading massive lockfiles
+        const isLockfile = ['package-lock.json', 'yarn.lock', 'poetry.lock', 'pnpm-lock.yaml'].some(file => filePath.toLowerCase().endsWith(file));
+        if (isLockfile) {
+            return {
+                output: '',
+                error: `Do not read lockfiles directly as they waste thousands of tokens. Please read the 'package.json', 'pyproject.toml', or equivalent source file to see dependencies.`,
+            };
+        }
+        // Handle SQLite databases natively by dumping the schema
+        if (filePath.toLowerCase().endsWith('.sqlite') || filePath.toLowerCase().endsWith('.db')) {
+            try {
+                const { stdout } = await execAsync(`sqlite3 "${absPath}" ".schema"`);
+                return {
+                    output: `## Database Schema for ${path.basename(absPath)}\n\`\`\`sql\n${stdout}\n\`\`\``,
+                };
+            }
+            catch (e) {
+                return {
+                    output: '',
+                    error: `Could not parse SQLite DB natively. Ensure 'sqlite3' CLI is installed. Error: ${e instanceof Error ? e.message : String(e)}`,
+                };
+            }
+        }
         let content = await fs.readFile(absPath, 'utf-8');
+        // Handle Jupyter Notebooks natively
+        if (filePath.toLowerCase().endsWith('.ipynb')) {
+            try {
+                const notebook = JSON.parse(content);
+                if (notebook && Array.isArray(notebook.cells)) {
+                    const cleanCells = [];
+                    for (const cell of notebook.cells) {
+                        const sourceArray = Array.isArray(cell.source) ? cell.source : [cell.source || ''];
+                        const source = sourceArray.join('');
+                        if (cell.cell_type === 'markdown') {
+                            cleanCells.push(source);
+                        }
+                        else if (cell.cell_type === 'code') {
+                            let cellStr = '```python\n' + source + '\n```';
+                            if (cell.outputs && Array.isArray(cell.outputs)) {
+                                const textOutputs = [];
+                                for (const out of cell.outputs) {
+                                    if (out.output_type === 'stream' && out.text) {
+                                        const text = Array.isArray(out.text) ? out.text.join('') : out.text;
+                                        textOutputs.push(text);
+                                    }
+                                    else if (out.data) {
+                                        if (out.data['text/plain']) {
+                                            const text = Array.isArray(out.data['text/plain']) ? out.data['text/plain'].join('') : out.data['text/plain'];
+                                            textOutputs.push(text);
+                                        }
+                                        else if (out.data['image/png'] || out.data['image/jpeg'] || out.data['image/svg+xml']) {
+                                            textOutputs.push('[Image Output]');
+                                        }
+                                        else if (out.data['text/html']) {
+                                            textOutputs.push('[HTML Output]');
+                                        }
+                                    }
+                                }
+                                if (textOutputs.length > 0) {
+                                    let joinedOutput = textOutputs.join('\n').trim();
+                                    const outLines = joinedOutput.split('\n');
+                                    if (outLines.length > 50) {
+                                        joinedOutput = outLines.slice(0, 50).join('\n') + '\n... (Output truncated)';
+                                    }
+                                    cellStr += '\n\n**Output:**\n```text\n' + joinedOutput + '\n```';
+                                }
+                            }
+                            cleanCells.push(cellStr);
+                        }
+                    }
+                    content = cleanCells.join('\n\n');
+                }
+            }
+            catch (err) {
+                content = `<!-- Failed to parse .ipynb cleanly, showing raw JSON -->\n${content}`;
+            }
+        }
+        // Handle CSV natively by formatting as a Markdown table
+        if (filePath.toLowerCase().endsWith('.csv')) {
+            try {
+                const rows = [];
+                let currentRow = [];
+                let currentCell = '';
+                let inQuotes = false;
+                for (let i = 0; i < content.length; i++) {
+                    const char = content[i];
+                    if (char === '"') {
+                        if (inQuotes && content[i + 1] === '"') {
+                            currentCell += '"';
+                            i++;
+                        }
+                        else {
+                            inQuotes = !inQuotes;
+                        }
+                    }
+                    else if (char === ',' && !inQuotes) {
+                        currentRow.push(currentCell.trim().replace(/\n/g, ' ').replace(/\|/g, '\\|'));
+                        currentCell = '';
+                    }
+                    else if ((char === '\n' || char === '\r') && !inQuotes) {
+                        if (char === '\r' && content[i + 1] === '\n')
+                            i++;
+                        currentRow.push(currentCell.trim().replace(/\n/g, ' ').replace(/\|/g, '\\|'));
+                        if (currentRow.some(cell => cell.length > 0)) {
+                            rows.push(currentRow);
+                        }
+                        currentRow = [];
+                        currentCell = '';
+                    }
+                    else {
+                        currentCell += char;
+                    }
+                }
+                if (currentCell !== '' || currentRow.length > 0) {
+                    currentRow.push(currentCell.trim().replace(/\n/g, ' ').replace(/\|/g, '\\|'));
+                    if (currentRow.some(cell => cell.length > 0))
+                        rows.push(currentRow);
+                }
+                if (rows.length > 0) {
+                    const header = rows[0];
+                    const MAX_CSV_ROWS = 250; // Generous truncation limit
+                    const isTruncated = rows.length > MAX_CSV_ROWS;
+                    const displayRows = isTruncated ? rows.slice(0, MAX_CSV_ROWS) : rows;
+                    let mdTable = `| ${header.join(' | ')} |\n`;
+                    mdTable += `| ${header.map(() => '---').join(' | ')} |\n`;
+                    for (let i = 1; i < displayRows.length; i++) {
+                        const row = displayRows[i];
+                        while (row.length < header.length)
+                            row.push('');
+                        mdTable += `| ${row.slice(0, header.length).join(' | ')} |\n`;
+                    }
+                    if (isTruncated) {
+                        mdTable += `\n*(Note: CSV truncated from ${rows.length} rows to ${MAX_CSV_ROWS} rows for safe viewing)*\n`;
+                    }
+                    content = mdTable;
+                }
+            }
+            catch (err) {
+                content = `<!-- Failed to parse .csv as table, showing raw text -->\n${content}`;
+            }
+        }
         if (targetElements && targetElements.length > 0) {
             content = extractSymbols(content, filePath, targetElements);
         }

package/oclif.manifest.json

@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "2.1.1"
+  "version": "2.1.2"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minovative-mind-cli",
   "description": "An automated AI agent powered by Vertex AI that helps you write software",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"