@indiccoder/mentis-cli 1.0.3

package/README.md

@@ -0,0 +1,90 @@
+# Mentis-CLI 🧠
+> **An Agentic, Multi-Model CLI Coding Assistant.**
+
+Mentis is a powerful terminal-based AI coding assistant that lives in your command line. It supports multiple LLM providers (Gemini, Ollama, OpenAI), agentic file operations, MCP (Model Context Protocol), and more.
+
+## ✨ Features
+
+*   **🤖 Multi-Model Support**: Switch seamlessly between **Gemini**, **Ollama** (Local), and **OpenAI**.
+*   **🛠️ Agentic Capabilities**: Mentis can read, write, list files, and search your codebase to understand context.
+*   **🌐 Web Intelligence**: Hybrid **Google** + **DuckDuckGo** search for documentation and error fixing (Zero-Config).
+*   **🗺️ Smart Context**: Automatically maps your repository structure for better spatial awareness.
+*   **💰 Cost Awareness**: Real-time token usage and cost estimation displayed after every response.
+*   **🧠 Persistent Memory**: Auto-saves sessions (`/resume`) and supports manual checkpoints (`/checkpoint`).
+*   **🔌 MCP Support**: Full [Model Context Protocol](https://github.com/modelcontextprotocol) client. Connect external tools like databases or memory servers.
+*   **🔍 Codebase Search**: Built-in `grep` tool to find code across your project.
+*   **🐚 Shell Integration**: Run shell commands (`/run`) and commit changes (`/commit`) directly from the agent.
+*   **🎨 Premium UI**: Beautiful terminal interface with modes (`PLAN` vs `BUILD`).
+
+## 🚀 Installation
+
+### From GitHub (Recommended)
+You can install Mentis directly from the repository, ensuring you always get the latest version (bypassing NPM delays).
+
+```bash
+npm install -g git+https://github.com/CoderVLSI/Mentis-CLI.git
+```
+
+### From Source (Dev)
+```bash
+git clone https://github.com/CoderVLSI/Mentis-CLI.git
+cd Mentis-CLI
+npm install
+npm run build
+npm link
+```
+
+## ⚙️ Configuration
+
+Start Mentis by typing:
+```bash
+mentis
+```
+
+### Setting up Models
+Type `/model` inside the CLI to launch the interactive configuration wizard:
+1.  **Select Provider**: Gemini, Ollama, or OpenAI.
+2.  **Select Model**: e.g., `gemini-2.5-flash`, `llama3`.
+3.  **Enter Credentials**: API Key (for cloud) or Base URL (for local).
+
+*Credentials are stored securely in `~/.mentisrc`.*
+
+## 📖 Usage
+
+### Modes
+*   **/plan**: Switch to high-level planning mode (Architecture, requirements).
+*   **/build**: Switch to code generation mode (Implementation).
+
+### Commands
+| Command | Description |
+| :--- | :--- |
+| `/help` | Show available commands |
+| `/model` | Configure AI provider and model (Interactive) |
+| `/resume` | Resume the last session |
+| `/checkpoint` | Manage saved sessions (`save`, `load`, `list`) |
+| `/search <query>` | Search for code in the current directory |
+| `/mcp connect <cmd>` | Connect an MCP Server (e.g., `npx -y @modelcontextprotocol/server-time`) |
+| `/run <cmd>` | Execute a shell command |
+| `/commit [msg]` | Stage and commit changes to Git |
+| `/add <file>` | Add a specific file to context |
+| `/drop <file>` | Remove a file from context |
+| `/clear` | Clear chat history |
+| `/exit` | Save and exit |
+
+### Example Workflow
+```text
+Mentis > /plan
+[PLAN] > Analyze this project structure and suggest improvements.
+
+Mentis > /build
+[BUILD] > Implement the FolderManager class in src/utils.ts.
+```
+
+## 🔒 Safety
+Mentis asks for **explicit approval** before writing or modifying any files, keeping you in control.
+
+## 🤝 Contributing
+Pull requests are welcome!
+
+## 📄 License
+ISC

package/debug_fs.js

@@ -0,0 +1,12 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const target = path.join(os.homedir(), 'mentis_debug_write_test.txt');
+console.log(`Attempting to write to: ${target}`);
+try {
+    fs.writeFileSync(target, 'Hello world');
+    console.log('Success!');
+} catch (e) {
+    console.error('Failed:', e);
+}

package/dist/checkpoint/CheckpointManager.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointManager = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+class CheckpointManager {
+    constructor() {
+        this.checkpointDir = path_1.default.join(os_1.default.homedir(), '.mentis', 'checkpoints');
+        fs_extra_1.default.ensureDirSync(this.checkpointDir);
+    }
+    save(name, history, files) {
+        const checkpoint = {
+            timestamp: Date.now(),
+            name,
+            history,
+            files
+        };
+        const filePath = path_1.default.join(this.checkpointDir, `${name}.json`);
+        fs_extra_1.default.writeJsonSync(filePath, checkpoint, { spaces: 2 });
+        return filePath;
+    }
+    load(name) {
+        const filePath = path_1.default.join(this.checkpointDir, `${name}.json`);
+        if (fs_extra_1.default.existsSync(filePath)) {
+            return fs_extra_1.default.readJsonSync(filePath);
+        }
+        return null;
+    }
+    list() {
+        if (!fs_extra_1.default.existsSync(this.checkpointDir))
+            return [];
+        return fs_extra_1.default.readdirSync(this.checkpointDir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => f.replace('.json', ''));
+    }
+    delete(name) {
+        const filePath = path_1.default.join(this.checkpointDir, `${name}.json`);
+        if (fs_extra_1.default.existsSync(filePath)) {
+            fs_extra_1.default.removeSync(filePath);
+            return true;
+        }
+        return false;
+    }
+    exists(name) {
+        const filePath = path_1.default.join(this.checkpointDir, `${name}.json`);
+        return fs_extra_1.default.existsSync(filePath);
+    }
+}
+exports.CheckpointManager = CheckpointManager;

package/dist/config/ConfigManager.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+class ConfigManager {
+    constructor() {
+        this.configPath = path_1.default.join(os_1.default.homedir(), '.mentisrc');
+        this.config = {
+            defaultProvider: 'ollama',
+            ollama: {
+                baseUrl: 'http://localhost:11434/v1',
+                model: 'llama3:latest'
+            },
+            gemini: {
+                model: 'gemini-2.5-flash'
+            },
+            glm: {
+                model: 'glm-4.6',
+            },
+        };
+        this.loadConfig();
+    }
+    loadConfig() {
+        try {
+            if (fs_extra_1.default.existsSync(this.configPath)) {
+                const fileContent = fs_extra_1.default.readFileSync(this.configPath, 'utf-8');
+                this.config = { ...this.config, ...JSON.parse(fileContent) };
+            }
+        }
+        catch (error) {
+            console.error('Error loading config:', error);
+        }
+    }
+    saveConfig() {
+        try {
+            fs_extra_1.default.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error('Error saving config:', error);
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        this.saveConfig();
+    }
+}
+exports.ConfigManager = ConfigManager;

package/dist/context/ContextManager.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextManager = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const RepoMapper_1 = require("./RepoMapper");
+class ContextManager {
+    constructor() {
+        this.files = new Map();
+        this.repoMapper = new RepoMapper_1.RepoMapper(process.cwd());
+    }
+    async addFile(filePath) {
+        try {
+            const absolutePath = path_1.default.resolve(process.cwd(), filePath);
+            if (!fs_extra_1.default.existsSync(absolutePath)) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+            const content = await fs_extra_1.default.readFile(absolutePath, 'utf-8');
+            this.files.set(absolutePath, content);
+            return `Added ${filePath} to context.`;
+        }
+        catch (error) {
+            return `Error adding file: ${error.message}`;
+        }
+    }
+    removeFile(filePath) {
+        const absolutePath = path_1.default.resolve(process.cwd(), filePath);
+        if (this.files.has(absolutePath)) {
+            this.files.delete(absolutePath);
+            return `Removed ${filePath} from context.`;
+        }
+        return `File not in context: ${filePath}`;
+    }
+    clear() {
+        this.files.clear();
+    }
+    getContextString() {
+        const repoMap = this.repoMapper.generateTree();
+        let context = `Repository Structure:\n${repoMap}\n\n`;
+        if (this.files.size > 0) {
+            context += 'Current File Context:\n\n';
+            for (const [filePath, content] of this.files.entries()) {
+                context += `--- File: ${path_1.default.basename(filePath)} ---\n${content}\n\n`;
+            }
+        }
+        return context;
+    }
+    getFiles() {
+        return Array.from(this.files.keys());
+    }
+}
+exports.ContextManager = ContextManager;

package/dist/context/RepoMapper.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoMapper = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+class RepoMapper {
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        this.ignorePatterns = new Set(['.git', 'node_modules', 'dist', 'coverage', '.DS_Store']);
+    }
+    generateTree() {
+        try {
+            // Try using git first for speed
+            const stdout = (0, child_process_1.execSync)('git ls-files --cached --others --exclude-standard', {
+                cwd: this.rootDir,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'] // Ignore stderr to avoid noise
+            });
+            const files = stdout.split('\n').filter(Boolean);
+            return this.buildTreeFromPaths(files);
+        }
+        catch (error) {
+            // Fallback to manual walk if not a git repo or git fails
+            return this.walk(this.rootDir, '');
+        }
+    }
+    buildTreeFromPaths(paths) {
+        const tree = {};
+        // Build object tree
+        for (const p of paths) {
+            const parts = p.split('/');
+            let current = tree;
+            for (const part of parts) {
+                if (!current[part]) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+        }
+        // Convert object tree to string
+        return this.renderTree(tree, '');
+    }
+    renderTree(node, indent) {
+        let result = '';
+        const keys = Object.keys(node).sort((a, b) => {
+            const aIsLeaf = Object.keys(node[a]).length === 0;
+            const bIsLeaf = Object.keys(node[b]).length === 0;
+            // Dirs first
+            if (!aIsLeaf && bIsLeaf)
+                return -1;
+            if (aIsLeaf && !bIsLeaf)
+                return 1;
+            return a.localeCompare(b);
+        });
+        keys.forEach((key, index) => {
+            const isLast = index === keys.length - 1;
+            const isDir = Object.keys(node[key]).length > 0;
+            const prefix = isLast ? '└── ' : '├── ';
+            const childIndent = isLast ? '    ' : '│   ';
+            result += `${indent}${prefix}${key}${isDir ? '/' : ''}\n`;
+            if (isDir) {
+                result += this.renderTree(node[key], indent + childIndent);
+            }
+        });
+        return result;
+    }
+    walk(currentPath, indent) {
+        try {
+            const files = fs_extra_1.default.readdirSync(currentPath);
+            let result = '';
+            // Cache stats to avoid repeated calls during sort
+            const fileStats = files.map(file => {
+                try {
+                    return {
+                        name: file,
+                        isDir: fs_extra_1.default.statSync(path_1.default.join(currentPath, file)).isDirectory()
+                    };
+                }
+                catch {
+                    return null;
+                }
+            }).filter(f => f);
+            // Sort: Directories first, then files
+            fileStats.sort((a, b) => {
+                if (a.isDir && !b.isDir)
+                    return -1;
+                if (!a.isDir && b.isDir)
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            const filteredFiles = fileStats.filter(f => !this.ignorePatterns.has(f.name));
+            filteredFiles.forEach((fileObj, index) => {
+                const isLast = index === filteredFiles.length - 1;
+                const prefix = isLast ? '└── ' : '├── ';
+                const childIndent = isLast ? '    ' : '│   ';
+                result += `${indent}${prefix}${fileObj.name}${fileObj.isDir ? '/' : ''}\n`;
+                if (fileObj.isDir) {
+                    result += this.walk(path_1.default.join(currentPath, fileObj.name), indent + childIndent);
+                }
+            });
+            return result;
+        }
+        catch (e) {
+            return `${indent}Error reading directory: ${e}\n`;
+        }
+    }
+}
+exports.RepoMapper = RepoMapper;

package/dist/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ReplManager_1 = require("./repl/ReplManager");
+async function main() {
+    const repl = new ReplManager_1.ReplManager();
+    await repl.start();
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/llm/AnthropicClient.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicClient = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+class AnthropicClient {
+    constructor(apiKey, model, baseUrl) {
+        this.client = new sdk_1.default({
+            apiKey: apiKey,
+            baseURL: baseUrl, // Optional, allows pointing to Z.ai or other proxies
+        });
+        this.model = model;
+    }
+    async chat(messages, tools) {
+        try {
+            // Convert ChatMessage (system, user, assistant) to Anthropic format
+            // Anthropic handles 'system' prompt via a separate parameter, not in the messages array.
+            let systemPrompt = undefined;
+            const anthropicMessages = [];
+            for (const msg of messages) {
+                if (msg.role === 'system') {
+                    systemPrompt = msg.content;
+                }
+                else {
+                    anthropicMessages.push({
+                        role: msg.role,
+                        content: msg.content
+                    });
+                }
+            }
+            // If no system prompt found in messages, use default
+            if (!systemPrompt) {
+                systemPrompt = 'You are Mentis, an expert AI coding assistant. You help users write code, debug issues, and explain concepts.';
+            }
+            const params = {
+                model: this.model,
+                messages: anthropicMessages,
+                system: systemPrompt,
+                max_tokens: 4096,
+            };
+            // TODO: Map tools if supported (Z.ai docs say they support tools)
+            // For now, simplicity first.
+            const response = await this.client.messages.create(params);
+            // Calculate usage (approximate if not provided, but Anthropic provides it)
+            const inputTokens = response.usage.input_tokens;
+            const outputTokens = response.usage.output_tokens;
+            // Extract content (handling text blocks)
+            let content = '';
+            for (const block of response.content) {
+                if (block.type === 'text') {
+                    content += block.text;
+                }
+            }
+            return {
+                content: content,
+                usage: {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error calling Anthropic API:', error.message);
+            throw error;
+        }
+    }
+}
+exports.AnthropicClient = AnthropicClient;

package/dist/llm/ModelInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/llm/OpenAIClient.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class OpenAIClient {
+    constructor(baseUrl, apiKey, model) {
+        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async chat(messages, tools, signal) {
+        try {
+            const requestBody = {
+                model: this.model,
+                messages: [
+                    { role: 'system', content: 'You are Mentis, an expert AI coding assistant. You help users write code, debug issues, and explain concepts. You are concise, accurate, and professional.' },
+                    ...messages
+                ],
+                temperature: 0.7,
+            };
+            if (tools && tools.length > 0) {
+                requestBody.tools = tools;
+                requestBody.tool_choice = 'auto';
+            }
+            const response = await axios_1.default.post(`${this.baseUrl}/chat/completions`, requestBody, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                signal: signal // Pass AbortSignal to Axios
+            });
+            const choice = response.data.choices[0];
+            return {
+                content: response.data.choices[0].message.content,
+                tool_calls: response.data.choices[0].message.tool_calls,
+                usage: {
+                    input_tokens: response.data.usage?.prompt_tokens || 0,
+                    output_tokens: response.data.usage?.completion_tokens || 0
+                }
+            };
+        }
+        catch (error) {
+            if (axios_1.default.isCancel(error) || error.name === 'AbortError' || error.code === 'ERR_CANCELED') {
+                // Rethrow as specific cancellation to be handled by caller
+                throw new Error('Request cancelled by user');
+            }
+            console.error('Error calling model API:', error.message);
+            if (error.response) {
+                console.error('Response data:', error.response.data);
+            }
+            throw error;
+        }
+    }
+}
+exports.OpenAIClient = OpenAIClient;

package/dist/mcp/JsonRpcClient.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcClient = void 0;
+const child_process_1 = require("child_process");
+const readline = __importStar(require("readline"));
+class JsonRpcClient {
+    constructor(command, args) {
+        this.sequence = 0;
+        this.pendingRequests = new Map();
+        this.process = (0, child_process_1.spawn)(command, args, {
+            stdio: ['pipe', 'pipe', 'inherit'], // stdin, stdout, stderr
+        });
+        if (!this.process.stdout) {
+            throw new Error('Failed to open stdout for MCP process');
+        }
+        const rl = readline.createInterface({ input: this.process.stdout });
+        rl.on('line', (line) => this.handleMessage(line));
+        this.process.on('error', (err) => console.error('MCP Process Error:', err));
+        this.process.on('exit', (code) => console.log('MCP Process Exited:', code));
+    }
+    handleMessage(line) {
+        try {
+            if (!line.trim())
+                return;
+            const message = JSON.parse(line);
+            // Handle Response
+            if (message.id !== undefined && (message.result !== undefined || message.error !== undefined)) {
+                const handler = this.pendingRequests.get(message.id);
+                if (handler) {
+                    this.pendingRequests.delete(message.id);
+                    if (message.error) {
+                        handler.reject(new Error(message.error.message));
+                    }
+                    else {
+                        handler.resolve(message.result);
+                    }
+                }
+            }
+            else {
+                // Handle Notification or Request from server (not implemented deep yet)
+                // console.log('Received notification from MCP:', message);
+            }
+        }
+        catch (e) {
+            console.error('Failed to parse MCP message:', line, e);
+        }
+    }
+    async sendRequest(method, params) {
+        const id = this.sequence++;
+        const request = {
+            jsonrpc: '2.0',
+            method,
+            params,
+            id,
+        };
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            try {
+                if (!this.process.stdin)
+                    throw new Error('Stdin not available');
+                const data = JSON.stringify(request) + '\n';
+                this.process.stdin.write(data);
+            }
+            catch (e) {
+                this.pendingRequests.delete(id);
+                reject(e);
+            }
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.process.stdin)
+            return;
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params,
+        };
+        this.process.stdin.write(JSON.stringify(notification) + '\n');
+    }
+    disconnect() {
+        this.process.kill();
+    }
+}
+exports.JsonRpcClient = JsonRpcClient;