@indiccoder/mentis-cli 1.1.3 → 1.1.5

package/dist/ui/ToolExecutor.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+/**
+ * Visual feedback for tool execution
+ * Shows colored icons, spinners, and grouped display
+ */
+class ToolExecutor {
+    /**
+     * Get colored text for a tool name
+     */
+    static colorToolName(toolName, color) {
+        switch (color) {
+            case 'blue': return chalk_1.default.blue(toolName);
+            case 'yellow': return chalk_1.default.yellow(toolName);
+            case 'cyan': return chalk_1.default.cyan(toolName);
+            case 'magenta': return chalk_1.default.magenta(toolName);
+            case 'green': return chalk_1.default.green(toolName);
+            case 'red': return chalk_1.default.red(toolName);
+            case 'gray': return chalk_1.default.gray(toolName);
+            default: return toolName;
+        }
+    }
+    /**
+     * Start a tool execution with visual feedback
+     */
+    static startExecution(toolName, args) {
+        const execution = {
+            toolName,
+            args,
+            status: 'running'
+        };
+        this.executions.push(execution);
+        // Get icon and color for tool type
+        const { icon, color } = this.getToolStyle(toolName);
+        // Format args for display (truncate long values)
+        const argsDisplay = this.formatArgs(args);
+        // Start spinner
+        const spinner = (0, ora_1.default)({
+            text: `${icon} ${this.colorToolName(toolName, color)} ${argsDisplay}`,
+            color: color
+        });
+        spinner.start();
+        this.spinners.set(toolName, spinner);
+    }
+    /**
+     * Complete a tool execution successfully
+     */
+    static completeExecution(toolName, result) {
+        const execution = this.executions.find(e => e.toolName === toolName);
+        if (execution) {
+            execution.status = 'completed';
+            execution.result = result;
+        }
+        const spinner = this.spinners.get(toolName);
+        if (spinner) {
+            const { icon } = this.getToolStyle(toolName);
+            spinner.succeed(`${icon} ${chalk_1.default.green(toolName)} completed`);
+            this.spinners.delete(toolName);
+        }
+    }
+    /**
+     * Mark a tool execution as failed
+     */
+    static failExecution(toolName, error) {
+        const execution = this.executions.find(e => e.toolName === toolName);
+        if (execution) {
+            execution.status = 'failed';
+            execution.error = error;
+        }
+        const spinner = this.spinners.get(toolName);
+        if (spinner) {
+            const { icon } = this.getToolStyle(toolName);
+            spinner.fail(`${icon} ${chalk_1.default.red(toolName)} failed: ${error}`);
+            this.spinners.delete(toolName);
+        }
+    }
+    /**
+     * Show grouped summary of all tool executions
+     */
+    static showSummary() {
+        if (this.executions.length === 0) {
+            return;
+        }
+        console.log('');
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.cyan('🔧 Tool Executions'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        for (const execution of this.executions) {
+            const { icon, color } = this.getToolStyle(execution.toolName);
+            const statusIcon = execution.status === 'completed' ? '✓' : execution.status === 'failed' ? '✗' : '…';
+            console.log(`${icon} ${this.colorToolName(execution.toolName, color)} ${chalk_1.default.dim(statusIcon)}`);
+        }
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log('');
+        // Reset for next batch
+        this.executions = [];
+    }
+    /**
+     * Get visual style for a tool type
+     */
+    static getToolStyle(toolName) {
+        const styles = {
+            'read_file': { icon: '📖', color: 'blue' },
+            'write_file': { icon: '📄', color: 'yellow' },
+            'edit_file': { icon: '✏️', color: 'yellow' },
+            'list_dir': { icon: '📁', color: 'cyan' },
+            'search_files': { icon: '🔍', color: 'magenta' },
+            'search_web': { icon: '🌐', color: 'blue' },
+            'run_command': { icon: '💻', color: 'green' },
+            'git_commit': { icon: '📝', color: 'green' }
+        };
+        return styles[toolName] || { icon: '🔧', color: 'gray' };
+    }
+    /**
+     * Format arguments for display
+     */
+    static formatArgs(args) {
+        const parts = [];
+        for (const [key, value] of Object.entries(args)) {
+            const strValue = String(value);
+            // Truncate long values
+            const display = strValue.length > 30 ? strValue.slice(0, 30) + '...' : strValue;
+            parts.push(`${key}=${chalk_1.default.dim(display)}`);
+        }
+        return parts.length > 0 ? chalk_1.default.dim(`(${parts.join(', ')})`) : '';
+    }
+    /**
+     * Show a simple inline tool usage message
+     */
+    static showInline(toolName, args) {
+        const { icon, color } = this.getToolStyle(toolName);
+        const argsDisplay = this.formatArgs(args);
+        console.log(chalk_1.default.dim(`  ${icon} ${this.colorToolName(toolName, color)} ${argsDisplay}`));
+    }
+    /**
+     * Clear all pending executions
+     */
+    static clear() {
+        for (const spinner of this.spinners.values()) {
+            spinner.stop();
+        }
+        this.spinners.clear();
+        this.executions = [];
+    }
+}
+exports.ToolExecutor = ToolExecutor;
+ToolExecutor.executions = [];
+ToolExecutor.spinners = new Map();

package/dist/ui/UIManager.js

@@ -19,12 +19,12 @@ class UIManager {
             whitespaceBreak: true,
         });
         console.log(gradient_string_1.default.pastel.multiline(logoText));
-        console.log(chalk_1.default.gray('  v1.1.3 - AI Coding Agent'));
+        console.log(chalk_1.default.gray('  v1.1.6 - AI Coding Agent'));
         console.log('');
     }
     static renderDashboard(config) {
         const { model, cwd } = config;
-        const version = 'v1.1.3';
+        const version = 'v1.1.6';
         // Layout: Left (Status/Welcome) | Right (Tips/Activity)
         // Total width ~80 chars. 
         // Left ~45, Right ~30.
@@ -74,5 +74,15 @@ class UIManager {
     static printSeparator() {
         console.log(chalk_1.default.gray('──────────────────────────────────────────────────'));
     }
+    static logBullet(text, color = 'white') {
+        const bullet = color === 'white' ? '●' : chalk_1.default[color]('●');
+        console.log(`  ${bullet} ${text}`);
+    }
+    static logSystem(text) {
+        console.log(chalk_1.default.dim(`    ${text}`));
+    }
+    static logTransition(text) {
+        console.log(`  ${chalk_1.default.red('+')} ${chalk_1.default.red(text)}`);
+    }
 }
 exports.UIManager = UIManager;

package/dist/utils/__mocks__/chalk.js

@@ -0,0 +1,20 @@
+"use strict";
+// Manual mock for chalk to avoid ESM issues in Jest
+module.exports = {
+    dim: (str) => str,
+    green: (str) => str,
+    yellow: (str) => str,
+    red: (str) => str,
+    gray: (str) => str,
+    bold: (str) => str,
+    cyan: (str) => str,
+    default: {
+        dim: (str) => str,
+        green: (str) => str,
+        yellow: (str) => str,
+        red: (str) => str,
+        gray: (str) => str,
+        bold: (str) => str,
+        cyan: (str) => str
+    }
+};

package/dist/utils/__tests__/ContextVisualizer.test.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Tests for ContextVisualizer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContextVisualizer_1 = require("../ContextVisualizer");
+describe('ContextVisualizer', () => {
+    let visualizer;
+    beforeEach(() => {
+        visualizer = new ContextVisualizer_1.ContextVisualizer();
+    });
+    describe('calculateUsage', () => {
+        it('should handle empty history', () => {
+            const history = [];
+            const usage = visualizer.calculateUsage(history);
+            // Includes 2000 char overhead = 500 tokens
+            expect(usage.tokens).toBe(500);
+            expect(usage.maxTokens).toBe(128000);
+            expect(usage).toHaveProperty('percentage');
+            expect(usage).toHaveProperty('tokens');
+            expect(usage).toHaveProperty('maxTokens');
+        });
+        it('should calculate tokens for messages', () => {
+            const history = [
+                { role: 'system', content: 'You are a helpful assistant.' },
+                { role: 'user', content: 'Hello' },
+                { role: 'assistant', content: 'Hi there!' }
+            ];
+            const usage = visualizer.calculateUsage(history);
+            expect(usage.tokens).toBeGreaterThan(500);
+            expect(usage.tokens).toBeLessThan(1000);
+            expect(usage.maxTokens).toBe(128000);
+        });
+        it('should handle large messages', () => {
+            const largeContent = 'x'.repeat(10000);
+            const history = [
+                { role: 'user', content: largeContent }
+            ];
+            const usage = visualizer.calculateUsage(history);
+            expect(usage.tokens).toBeGreaterThan(1500);
+        });
+    });
+    describe('formatBar', () => {
+        it('should format bar at low usage', () => {
+            const usage = { tokens: 1000, percentage: 5, maxTokens: 128000 };
+            const bar = visualizer.formatBar(usage);
+            // Check that bar contains expected data (without chalk dependency)
+            expect(bar).toContain('5');
+            expect(bar).toContain('1k');
+            expect(bar).toContain('128');
+        });
+        it('should format bar at medium usage', () => {
+            const usage = { tokens: 50000, percentage: 40, maxTokens: 128000 };
+            const bar = visualizer.formatBar(usage);
+            expect(bar).toContain('40');
+            expect(bar).toContain('50k');
+        });
+        it('should format bar at high usage', () => {
+            const usage = { tokens: 100000, percentage: 80, maxTokens: 128000 };
+            const bar = visualizer.formatBar(usage);
+            expect(bar).toContain('80');
+            expect(bar).toContain('100k');
+        });
+    });
+    describe('shouldCompact', () => {
+        it('should return false for low percentage', () => {
+            const history = [
+                { role: 'user', content: 'small message' }
+            ];
+            const shouldCompact = visualizer.shouldCompact(history);
+            expect(shouldCompact).toBe(false);
+        });
+        it('should return true at 80% threshold', () => {
+            // Create enough content to exceed 80%
+            // 80% of 128000 tokens = 102400 tokens = ~409600 chars
+            // Subtract 2000 overhead = ~407400 chars needed
+            const largeContent = 'x'.repeat(410000);
+            const history = [
+                { role: 'system', content: largeContent },
+                { role: 'user', content: largeContent }
+            ];
+            const shouldCompact = visualizer.shouldCompact(history);
+            expect(shouldCompact).toBe(true);
+        });
+    });
+    describe('setMaxTokens', () => {
+        it('should update max tokens', () => {
+            visualizer.setMaxTokens(32000);
+            const history = [];
+            const usage = visualizer.calculateUsage(history);
+            expect(usage.maxTokens).toBe(32000);
+            expect(usage.percentage).toBeGreaterThan(1); // Should be higher percentage with smaller max
+        });
+    });
+});

package/docs/MCP_INTEGRATION.md

@@ -0,0 +1,290 @@
+# MCP (Model Context Protocol) Integration
+
+Mentis CLI now supports MCP (Model Context Protocol) servers, allowing you to extend functionality with external tools and services.
+
+## Overview
+
+MCP allows you to:
+- Connect to external services (search, databases, APIs, etc.)
+- Use additional tools beyond the built-in ones
+- Create a customizable toolkit for your AI assistant
+
+## Preconfigured MCP Servers
+
+The following MCP servers are pre-configured:
+
+### 1. Exa Search
+- **Purpose**: Web search via Exa API
+- **Setup**: Requires `EXA_API_KEY` environment variable
+- **Command**: `npx -y @exa-labs/mcp-server-exa`
+
+### 2. Memory Server
+- **Purpose**: Persistent memory storage for conversations
+- **Setup**: No additional configuration required
+- **Command**: `npx -y @modelcontextprotocol/server-memory`
+
+### 3. Filesystem Server
+- **Purpose**: Enhanced filesystem operations
+- **Setup**: No additional configuration required
+- **Command**: `npx -y @modelcontextprotocol/server-filesystem <directory>`
+
+### 4. GitHub Server
+- **Purpose**: GitHub repository management and operations
+- **Setup**: Requires `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable
+- **Command**: `npx -y @modelcontextprotocol/server-github`
+
+### 5. Puppeteer Server
+- **Purpose**: Web browser automation and scraping
+- **Setup**: No additional configuration required
+- **Command**: `npx -y @modelcontextprotocol/server-puppeteer`
+
+### 6. Brave Search Server
+- **Purpose**: Web search via Brave Search API
+- **Setup**: Requires `BRAVE_API_KEY` environment variable
+- **Command**: `npx -y @modelcontextprotocol/server-brave-search`
+
+### 7. Slack Server
+- **Purpose**: Slack workspace integration
+- **Setup**: Requires `SLACK_BOT_TOKEN` environment variable
+- **Command**: `npx -y @modelcontextprotocol/server-slack`
+
+## MCP Commands
+
+### List Servers
+```bash
+/mcp list
+```
+Shows all configured MCP servers and their connection status.
+
+### Connect to Server
+```bash
+# Interactive selection
+/mcp connect
+
+# Direct connection
+/mcp connect "Exa Search"
+```
+
+### Disconnect from Server
+```bash
+# Interactive selection
+/mcp disconnect
+
+# Disconnect specific server
+/mcp disconnect "Exa Search"
+
+# Disconnect all
+/mcp disconnect all
+```
+
+### Add Custom Server
+```bash
+/mcp add "My Server" npx -y @my/mcp-server
+```
+
+### Remove Server
+```bash
+# Interactive selection
+/mcp remove
+
+# Remove specific server
+/mcp remove "My Server"
+```
+
+### Test Connection
+```bash
+# Interactive selection
+/mcp test
+
+# Test specific server
+/mcp test "Exa Search"
+```
+
+### View Configuration
+```bash
+/mcp config
+```
+Shows the full MCP configuration file location and contents.
+
+## Configuration
+
+MCP servers are configured in `~/.mentis/mcp.json`. The configuration includes:
+
+```json
+{
+  "servers": [
+    {
+      "name": "Exa Search",
+      "command": "npx",
+      "args": ["-y", "@exa-labs/mcp-server-exa"],
+      "description": "Web search and information retrieval via Exa API",
+      "autoConnect": false,
+      "env": {
+        "EXA_API_KEY": ""
+      }
+    }
+  ]
+}
+```
+
+### Server Configuration Fields
+
+- `name`: Display name for the server
+- `command`: Command to run (e.g., `npx`, `node`)
+- `args`: Array of arguments for the command
+- `description`: Optional description of what the server does
+- `autoConnect`: If `true`, automatically connects on startup
+- `env`: Optional environment variables required by the server
+
+## Environment Variables
+
+Some MCP servers require API keys or other configuration:
+
+### Exa Search
+```bash
+export EXA_API_KEY=your_exa_api_key
+```
+
+### GitHub Server
+```bash
+export GITHUB_PERSONAL_ACCESS_TOKEN=your_github_token
+```
+
+### Brave Search
+```bash
+export BRAVE_API_KEY=your_brave_api_key
+```
+
+### Slack Server
+```bash
+export SLACK_BOT_TOKEN=your_slack_bot_token
+```
+
+## Usage Examples
+
+### Exa Search Integration
+
+1. Set up your Exa API key:
+   ```bash
+   export EXA_API_KEY=your_api_key_here
+   ```
+
+2. Connect to the Exa Search server:
+   ```bash
+   /mcp connect "Exa Search"
+   ```
+
+3. Use the search functionality:
+   ```
+   Search for recent developments in TypeScript
+   ```
+
+   The AI will now have access to the Exa search tools and can perform web searches.
+
+### Memory Server
+
+1. Connect to the memory server:
+   ```bash
+   /mcp connect Memory
+   ```
+
+2. The AI can now store and retrieve information across sessions.
+
+### GitHub Integration
+
+1. Set up your GitHub token:
+   ```bash
+   export GITHUB_PERSONAL_ACCESS_TOKEN=your_token_here
+   ```
+
+2. Connect to the GitHub server:
+   ```bash
+   /mcp connect GitHub
+   ```
+
+3. Use GitHub functionality:
+   ```
+   List the recent issues in the mentis-cli repository
+   Create a pull request for my changes
+   ```
+
+## Auto-Connect
+
+To automatically connect to specific servers on startup, set `autoConnect: true` in the server configuration:
+
+```json
+{
+  "servers": [
+    {
+      "name": "Memory",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"],
+      "autoConnect": true
+    }
+  ]
+}
+```
+
+## Troubleshooting
+
+### Connection Issues
+
+1. **Missing API Keys**: Ensure all required environment variables are set
+2. **Network Issues**: Check your internet connection
+3. **Server Not Found**: Verify the MCP server package is correct
+
+### Test Connection
+
+Use the test command to verify connectivity:
+```bash
+/mcp test <server_name>
+```
+
+### View Logs
+
+MCP connection errors are logged with detailed information. Check the console output for specific error messages.
+
+## Creating Custom MCP Servers
+
+You can add any MCP server to your configuration:
+
+```bash
+/mcp add "My Custom Server" node /path/to/my-server.js
+```
+
+Or manually edit `~/.mentis/mcp.json`:
+
+```json
+{
+  "servers": [
+    {
+      "name": "My Custom Server",
+      "command": "node",
+      "args": ["/path/to/my-server.js"],
+      "description": "My custom MCP server",
+      "autoConnect": false
+    }
+  ]
+}
+```
+
+## Security Considerations
+
+- **API Keys**: Store API keys securely using environment variables
+- **Server Trust**: Only connect to MCP servers from trusted sources
+- **File Access**: Be cautious with filesystem servers that have broad access
+- **Network**: MCP servers may make network requests on your behalf
+
+## Best Practices
+
+1. **Environment Variables**: Always use environment variables for sensitive data
+2. **Minimal Scope**: Configure servers with minimal required permissions
+3. **Regular Updates**: Keep MCP server packages updated
+4. **Monitor Usage**: Check which tools are being used and how frequently
+
+## Resources
+
+- [MCP Specification](https://modelcontextprotocol.io/)
+- [Exa API Documentation](https://docs.exa.ai/)
+- [Model Context Protocol GitHub](https://github.com/modelcontextprotocol)
+- [Available MCP Servers](https://mcp-examples.now.sh/)