minovative-mind-cli 2.1.0 → 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)
@@ -112,6 +115,7 @@ Hot-swap during a session using `/models`:
 | `/commit`       | Generate a conventional commit message from your diff            |
 | `/revert`       | Undo changes from the last turn, or toggle the revert logger     |
 | `/chats`        | View, resume, or delete previous chat sessions                   |
+| `/workspaces`   | Manage active workspaces and linked cross-repo aliases           |
 | `stop`          | Abort generation immediately                                     |
 
 ---

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/dist/services/contextAgent.js

@@ -4,7 +4,7 @@ import pc from 'picocolors';
 import { createContextAgentSession, createIntentRouterSession, createWebSearchAgentSession, createExecutionComplexitySession, } from './ai.js';
 import { evaluateInvestigationComplexity } from './investigationComplexity.js';
 import { InvestigationOrchestrator } from './orchestration/investigationOrchestrator.js';
-import { isSubAgentsEnabled, listDirectory, grepSearch, readFile, traceDependencies, findRecentChanges } from './agent-tools.js';
+import { isSubAgentsEnabled, executeTool } from './agent-tools.js';
 import { debugLog } from '../utils/logger.js';
 import { buildDependencyGraph } from '../utils/dependencyTracer.js';
 import { runEphemeralScript } from '../utils/analysisRunner.js';
@@ -198,7 +198,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     let primaryProjectType = 'Unknown';
     for (const { alias, root } of allRoots) {
         const label = alias ? `@${alias} (${root})` : `Primary Workspace (${root})`;
-        const treeResult = await listDirectory(root, '.', 10);
+        const treeResult = await executeTool(root, 'list_directory', { dirPath: '.', maxDepth: 10 });
         let tree = treeResult.output;
         if (tree.length > 30000) {
             tree = tree.substring(0, 30000) + '\\n... (Project tree truncated due to size)';
@@ -328,7 +328,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 debugLog(`Context Agent finished. Selected files: ${JSON.stringify(filesToRead)}`);
                 for (const filePath of filesToRead) {
                     if (!relevantFiles.has(filePath)) {
-                        const readResult = await readFile(workspaceRoot, filePath);
+                        const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
                         if (!readResult.error) {
                             relevantFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
                         }
@@ -342,15 +342,23 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 // Execution Agent won't break imports when modifying/deleting/renaming.
                 const MAX_TOTAL_FILES = 15;
                 try {
-                    const graph = await buildDependencyGraph(workspaceRoot);
+                    const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
                     const autoDiscovered = new Set();
                     for (const filePath of filesToRead) {
-                        const reverseDeps = graph.getImportedBy(filePath);
-                        for (const dep of reverseDeps) {
-                            if (!filesToRead.includes(dep) && !autoDiscovered.has(dep)) {
-                                autoDiscovered.add(dep);
+                        try {
+                            const resolved = resolveAndValidateMultiWorkspacePath(workspaceRoot, filePath);
+                            const graph = await buildDependencyGraph(resolved.workspaceRoot);
+                            const reverseDeps = graph.getImportedBy(resolved.relativePath);
+                            for (const dep of reverseDeps) {
+                                const aliasedDep = resolved.alias ? `@${resolved.alias}/${dep}` : dep;
+                                if (!filesToRead.includes(aliasedDep) && !autoDiscovered.has(aliasedDep)) {
+                                    autoDiscovered.add(aliasedDep);
+                                }
                             }
                         }
+                        catch (e) {
+                            // Ignore path resolution errors for trace dependencies
+                        }
                     }
                     // Merge auto-discovered dependents, respecting the file cap
                     const remaining = MAX_TOTAL_FILES - relevantFiles.size;
@@ -359,7 +367,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                         if (added >= remaining)
                             break;
                         if (!relevantFiles.has(dep)) {
-                            const readResult = await readFile(workspaceRoot, dep);
+                            const readResult = await executeTool(workspaceRoot, 'read_file', { filePath: dep });
                             if (!readResult.error) {
                                 relevantFiles.set(dep, { text: readResult.output, inlineData: readResult.inlineData });
                                 added++;
@@ -389,7 +397,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 const filesToRead = args.files || [];
                 let output = '';
                 for (const filePath of filesToRead) {
-                    const readResult = await readFile(workspaceRoot, filePath);
+                    const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
                     if (!readResult.error) {
                         relevantFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
                         output += `\n--- File: ${filePath} ---\n${readResult.output}\n`;
@@ -406,7 +414,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'list_directory') {
-                const listRes = await listDirectory(workspaceRoot, args.dirPath, args.maxDepth || 1);
+                const listRes = await executeTool(workspaceRoot, 'list_directory', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
@@ -418,7 +426,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'search_codebase') {
-                const grepRes = await grepSearch(workspaceRoot, args.pattern, args.fileGlob);
+                const grepRes = await executeTool(workspaceRoot, 'grep_search', { ...args, workspace: 'all' });
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
@@ -427,44 +435,16 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'semantic_search') {
-                const query = args.query;
-                const topK = args.topK || 5;
-                let output = '';
-                try {
-                    const { getEmbeddingIndex } = await import('./embeddingIndex.js');
-                    const index = getEmbeddingIndex();
-                    if (!index.isReady()) {
-                        // Lazy load from disk or build if missing
-                        const loaded = await index.load(workspaceRoot);
-                        if (!loaded) {
-                            if (onProgress)
-                                onProgress('Building semantic search index (first run)...');
-                            await index.buildIndex(workspaceRoot, onProgress);
-                            await index.save(workspaceRoot);
-                        }
-                    }
-                    const results = await index.search(query, topK);
-                    if (results.length === 0) {
-                        output = 'No semantically similar code found. (Index might be empty or embedding failed)';
-                    }
-                    else {
-                        output = results
-                            .map((r) => `[Score: ${r.score.toFixed(3)}] ${r.filePath}:${r.startLine}-${r.endLine}\n${r.preview}`)
-                            .join('\n---\n');
-                    }
-                }
-                catch (e) {
-                    output = `Semantic search failed: ${e.message}`;
-                }
+                const semRes = await executeTool(workspaceRoot, 'semantic_search', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
-                        response: { output },
+                        response: { output: semRes.output },
                     },
                 });
             }
             else if (call.name === 'read_file') {
-                const readRes = await readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
+                const readRes = await executeTool(workspaceRoot, 'read_file', args);
                 if (!readRes.error) {
                     relevantFiles.set(args.filePath, { text: readRes.output, inlineData: readRes.inlineData });
                 }
@@ -506,7 +486,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 }
             }
             else if (call.name === 'find_dependencies') {
-                const depResult = await traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+                const depResult = await executeTool(workspaceRoot, 'find_dependencies', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,
@@ -515,7 +495,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 });
             }
             else if (call.name === 'find_recent_changes') {
-                const recentRes = await findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+                const recentRes = await executeTool(workspaceRoot, 'find_recent_changes', args);
                 functionResponses.push({
                     functionResponse: {
                         name: call.name,

package/oclif.manifest.json

@@ -65,5 +65,5 @@
       ]
     }
   },
-  "version": "2.1.0"
+  "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.0",
+  "version": "2.1.2",
   "author": "Daniel Ward",
   "bin": {
     "minovative-mind-cli": "bin/run.js"