@indiccoder/mentis-cli 1.0.3

package/dist/tools/FileTools.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDirTool = exports.ReadFileTool = exports.WriteFileTool = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+class WriteFileTool {
+    constructor() {
+        this.name = 'write_file';
+        this.description = 'Write content to a file. Overwrites if exists. Creates directories if needed.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'The path to the file to write',
+                },
+                content: {
+                    type: 'string',
+                    description: 'The content to write to the file',
+                },
+            },
+            required: ['filePath', 'content'],
+        };
+    }
+    async execute(args) {
+        try {
+            const absolutePath = path_1.default.resolve(args.filePath);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(absolutePath));
+            await fs_extra_1.default.writeFile(absolutePath, args.content, 'utf-8');
+            return `Successfully wrote to ${args.filePath}`;
+        }
+        catch (error) {
+            return `Error writing file: ${error.message}`;
+        }
+    }
+}
+exports.WriteFileTool = WriteFileTool;
+class ReadFileTool {
+    constructor() {
+        this.name = 'read_file';
+        this.description = 'Read content from a file.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'The path to the file to read',
+                },
+            },
+            required: ['filePath'],
+        };
+    }
+    async execute(args) {
+        try {
+            const absolutePath = path_1.default.resolve(args.filePath);
+            if (!await fs_extra_1.default.pathExists(absolutePath)) {
+                return `Error: File not found at ${args.filePath}`;
+            }
+            const content = await fs_extra_1.default.readFile(absolutePath, 'utf-8');
+            return content;
+        }
+        catch (error) {
+            return `Error reading file: ${error.message}`;
+        }
+    }
+}
+exports.ReadFileTool = ReadFileTool;
+class ListDirTool {
+    constructor() {
+        this.name = 'list_dir';
+        this.description = 'List files and directories in a path.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'The directory path to list',
+                },
+            },
+            required: ['path'],
+        };
+    }
+    async execute(args) {
+        try {
+            const targetPath = path_1.default.resolve(args.path);
+            if (!await fs_extra_1.default.pathExists(targetPath)) {
+                return `Error: Directory not found at ${args.path}`;
+            }
+            const files = await fs_extra_1.default.readdir(targetPath);
+            return files.join('\n');
+        }
+        catch (error) {
+            return `Error listing directory: ${error.message}`;
+        }
+    }
+}
+exports.ListDirTool = ListDirTool;

package/dist/tools/GitTools.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitPullTool = exports.GitPushTool = exports.GitCommitTool = exports.GitDiffTool = exports.GitStatusTool = void 0;
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const execAsync = util_1.default.promisify(child_process_1.exec);
+class GitStatusTool {
+    constructor() {
+        this.name = 'git_status';
+        this.description = 'Check the status of the git repository.';
+        this.parameters = {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+    }
+    async execute(args) {
+        try {
+            const { stdout } = await execAsync('git status');
+            return stdout;
+        }
+        catch (error) {
+            return `Error running git status: ${error.message}`;
+        }
+    }
+}
+exports.GitStatusTool = GitStatusTool;
+class GitDiffTool {
+    constructor() {
+        this.name = 'git_diff';
+        this.description = 'Show changes in the git repository.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                cached: {
+                    type: 'boolean',
+                    description: 'Show cached (staged) changes.'
+                }
+            },
+            required: []
+        };
+    }
+    async execute(args) {
+        try {
+            const cmd = args.cached ? 'git diff --cached' : 'git diff';
+            const { stdout } = await execAsync(cmd);
+            return stdout || 'No changes found.';
+        }
+        catch (error) {
+            return `Error running git diff: ${error.message}`;
+        }
+    }
+}
+exports.GitDiffTool = GitDiffTool;
+class GitCommitTool {
+    constructor() {
+        this.name = 'git_commit';
+        this.description = 'Commit changes to the git repository.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                message: {
+                    type: 'string',
+                    description: 'The commit message.'
+                }
+            },
+            required: ['message']
+        };
+    }
+    async execute(args) {
+        try {
+            // Escape double quotes in message
+            const safeMessage = args.message.replace(/"/g, '\\"');
+            const { stdout } = await execAsync(`git commit -m "${safeMessage}"`);
+            return stdout;
+        }
+        catch (error) {
+            return `Error running git commit: ${error.message}`;
+        }
+    }
+}
+exports.GitCommitTool = GitCommitTool;
+class GitPushTool {
+    constructor() {
+        this.name = 'git_push';
+        this.description = 'Push changes to the remote repository.';
+        this.parameters = {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+    }
+    async execute(args) {
+        try {
+            const { stdout, stderr } = await execAsync('git push');
+            return stdout + (stderr ? `\nStderr: ${stderr}` : '');
+        }
+        catch (error) {
+            return `Error running git push: ${error.message}`;
+        }
+    }
+}
+exports.GitPushTool = GitPushTool;
+class GitPullTool {
+    constructor() {
+        this.name = 'git_pull';
+        this.description = 'Pull changes from the remote repository.';
+        this.parameters = {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+    }
+    async execute(args) {
+        try {
+            const { stdout } = await execAsync('git pull');
+            return stdout;
+        }
+        catch (error) {
+            return `Error running git pull: ${error.message}`;
+        }
+    }
+}
+exports.GitPullTool = GitPullTool;

package/dist/tools/PersistentShellTool.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentShellTool = void 0;
+class PersistentShellTool {
+    constructor(shell) {
+        this.name = 'run_shell';
+        this.description = 'Execute a shell command in a persistent session. Use this for running tests, build scripts, or git commands. State (env vars, cwd) is preserved.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'The shell command to execute.'
+                }
+            },
+            required: ['command']
+        };
+        this.shell = shell;
+    }
+    async execute(args) {
+        try {
+            const output = await this.shell.execute(args.command);
+            return output || 'Command executed with no output.';
+        }
+        catch (error) {
+            return `Error executing command: ${error.message}`;
+        }
+    }
+}
+exports.PersistentShellTool = PersistentShellTool;

package/dist/tools/SearchTools.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunShellTool = exports.SearchFileTool = void 0;
+const child_process_1 = require("child_process");
+const util_1 = __importDefault(require("util"));
+const execAsync = util_1.default.promisify(child_process_1.exec);
+class SearchFileTool {
+    constructor() {
+        this.name = 'search_files';
+        this.description = 'Search for a string pattern in files within the current directory recursively.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The string or regular expression to search for.'
+                },
+                path: {
+                    type: 'string',
+                    description: 'Optional path to limit search (default: .)'
+                }
+            },
+            required: ['query']
+        };
+    }
+    async execute(args) {
+        try {
+            const searchPath = args.path || '.';
+            // Use git grep if available as it respects .gitignore, otherwise fallback to grep or findstr
+            // For simplicity/cross-platform in this environment, let's try a heuristic:
+            // win32 usually has findstr, but git grep is better if installed. 
+            // We'll assume standard 'grep -r' works in many envs or user has git bash.
+            // Actually, safer to use 'git grep -n "query"' if inside a repo.
+            const command = `git grep -n "${args.query}" ${searchPath}`;
+            const { stdout } = await execAsync(command);
+            return stdout || 'No matches found.';
+        }
+        catch (error) {
+            // grep returns exit code 1 if not found, distinct from error
+            if (error.code === 1)
+                return 'No matches found.';
+            return `Error searching: ${error.message}`;
+        }
+    }
+}
+exports.SearchFileTool = SearchFileTool;
+class RunShellTool {
+    constructor() {
+        this.name = 'run_shell';
+        this.description = 'Execute a shell command. Use this for running tests, build scripts, or git commands.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'The shell command to execute.'
+                }
+            },
+            required: ['command']
+        };
+    }
+    async execute(args) {
+        // Safety: We might want to block dangerous commands, but user approval is better.
+        // For now, relies on the ReplManager's safety/approval loop if we add it for this tool too.
+        // Or we just allow it since it's a CLI tool for devs.
+        try {
+            const { stdout, stderr } = await execAsync(args.command);
+            let result = '';
+            if (stdout)
+                result += `STDOUT:\n${stdout}\n`;
+            if (stderr)
+                result += `STDERR:\n${stderr}\n`;
+            return result || 'Command executed with no output.';
+        }
+        catch (error) {
+            return `Error executing command: ${error.message}\nSTDOUT: ${error.stdout}\nSTDERR: ${error.stderr}`;
+        }
+    }
+}
+exports.RunShellTool = RunShellTool;

package/dist/tools/Tool.js

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

package/dist/tools/WebSearchTool.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSearchTool = void 0;
+const duck_duck_scrape_1 = require("duck-duck-scrape");
+const chalk_1 = __importDefault(require("chalk"));
+class WebSearchTool {
+    constructor() {
+        this.name = 'search_web';
+        this.description = 'Search the internet for documentation, libraries, or solutions to errors. Returns snippets of top results.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query.'
+                }
+            },
+            required: ['query']
+        };
+    }
+    async execute(args) {
+        try {
+            // Priority 1: Google Search
+            try {
+                // Dynamic import to avoid build issues if types are missing
+                const { search: googleSearch } = require('google-sr');
+                console.log(chalk_1.default.dim(`  Searching Google for: "${args.query}"...`));
+                const googleResults = await googleSearch({
+                    query: args.query,
+                    limit: 5,
+                });
+                if (googleResults && googleResults.length > 0) {
+                    const formatted = googleResults.map(r => `[${r.title}](${r.link})\n${r.description || 'No description.'}`).join('\n\n');
+                    return `Top Google Results:\n\n${formatted}`;
+                }
+            }
+            catch (googleError) {
+                console.log(chalk_1.default.dim(`  Google search failed (${googleError.message}), failing over to DuckDuckGo...`));
+            }
+            // Priority 2: DuckDuckGo Fallback
+            console.log(chalk_1.default.dim(`  Searching DuckDuckGo for: "${args.query}"...`));
+            const ddgResults = await (0, duck_duck_scrape_1.search)(args.query, {
+                safeSearch: 0
+            });
+            if (!ddgResults.results || ddgResults.results.length === 0) {
+                return 'No results found.';
+            }
+            // Return top 5 results
+            const topResults = ddgResults.results.slice(0, 5).map(r => `[${r.title}](${r.url})\n${r.description || 'No description found.'}`).join('\n\n');
+            return `Top Search Results (via DDG):\n\n${topResults}`;
+        }
+        catch (error) {
+            return `Error searching web: ${error.message}`;
+        }
+    }
+}
+exports.WebSearchTool = WebSearchTool;

package/dist/ui/UIManager.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UIManager = void 0;
+const figlet_1 = __importDefault(require("figlet"));
+const gradient_string_1 = __importDefault(require("gradient-string"));
+const boxen_1 = __importDefault(require("boxen"));
+const chalk_1 = __importDefault(require("chalk"));
+class UIManager {
+    static displayLogo() {
+        console.clear();
+        const logoText = figlet_1.default.textSync('MENTIS', {
+            font: 'ANSI Shadow', // Use a block-like font
+            horizontalLayout: 'default',
+            verticalLayout: 'default',
+            width: 100,
+            whitespaceBreak: true,
+        });
+        console.log(gradient_string_1.default.pastel.multiline(logoText));
+        console.log(chalk_1.default.gray('  v1.0.0 - AI Coding Agent'));
+        console.log('');
+    }
+    static displayWelcome() {
+        console.log((0, boxen_1.default)(`${chalk_1.default.bold('Welcome to Mentis-CLI')}\n\n` +
+            `• Type ${chalk_1.default.cyan('/help')} for commands.\n` +
+            `• Type ${chalk_1.default.cyan('/config')} to setup your model.\n` +
+            `• Start typing to chat with your agent.`, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan',
+        }));
+    }
+    static printSeparator() {
+        console.log(chalk_1.default.gray('──────────────────────────────────────────────────'));
+    }
+}
+exports.UIManager = UIManager;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@indiccoder/mentis-cli",
+  "version": "1.0.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "An Agentic, Multi-Model CLI Coding Assistant",
+  "main": "index.js",
+  "bin": {
+    "mentis": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "agent",
+    "gemini",
+    "ollama",
+    "mcp"
+  ],
+  "author": "CoderVLSI",
+  "license": "ISC",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@types/marked": "^5.0.2",
+    "@types/marked-terminal": "^6.1.1",
+    "@types/pdf-parse": "^1.1.5",
+    "@types/uuid": "^10.0.0",
+    "axios": "^1.13.2",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "cli-highlight": "^2.1.11",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "duck-duck-scrape": "^2.2.7",
+    "fast-glob": "^3.3.3",
+    "figlet": "^1.9.4",
+    "fs-extra": "^11.3.2",
+    "google-sr": "^6.0.0",
+    "gradient-string": "^3.0.0",
+    "inquirer": "^13.1.0",
+    "marked": "^17.0.1",
+    "marked-terminal": "^7.3.0",
+    "ora": "^9.0.0",
+    "pdf-parse": "^2.4.5",
+    "screenshot-desktop": "^1.15.3",
+    "uuid": "^13.0.0",
+    "vscode-ripgrep": "^1.13.2",
+    "xlsx": "^0.18.5"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/gradient-string": "^1.1.6",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.0.2",
+    "typescript": "^5.9.3"
+  }
+}

package/scripts/test_features.ts

@@ -0,0 +1,48 @@
+import { WebSearchTool } from '../src/tools/WebSearchTool';
+import { RepoMapper } from '../src/context/RepoMapper';
+import chalk from 'chalk';
+import path from 'path';
+
+async function runTests() {
+    console.log(chalk.cyan('🧪 Starting Feature Tests...\n'));
+
+    // --- Test 1: Web Search ---
+    console.log(chalk.yellow('1. Testing Web Search Tool...'));
+    const webTool = new WebSearchTool();
+    try {
+        const result = await webTool.execute({ query: 'nodejs latest version' });
+        if (result.includes('Node.js') || result.includes('v')) {
+            console.log(chalk.green('✅ Web Search Success!'));
+            console.log(chalk.dim(result.substring(0, 150) + '...'));
+        } else {
+            console.log(chalk.red('❌ Web Search returned unexpected results.'));
+            console.log(result);
+        }
+    } catch (e: any) {
+        console.log(chalk.red(`❌ Web Search Failed: ${e.message}`));
+    }
+    console.log('');
+
+    // --- Test 2: Repo Mapper ---
+    console.log(chalk.yellow('2. Testing Repo Mapper...'));
+    try {
+        const mapper = new RepoMapper(process.cwd());
+        const tree = mapper.generateTree();
+
+        if (tree.includes('src/') && tree.includes('package.json')) {
+            console.log(chalk.green('✅ Repo Map Success!'));
+            console.log(chalk.dim('Tree preview:'));
+            const preview = tree.split('\n').slice(0, 10).join('\n');
+            console.log(preview);
+        } else {
+            console.log(chalk.red('❌ Repo Map expected src/ and package.json but got:'));
+            console.log(tree);
+        }
+    } catch (e: any) {
+        console.log(chalk.red(`❌ Repo Map Failed: ${e.message}`));
+    }
+
+    console.log(chalk.cyan('\n🏁 Tests Completed.'));
+}
+
+runTests();

package/scripts/test_glm.ts

@@ -0,0 +1,53 @@
+
+import axios from 'axios';
+import inquirer from 'inquirer';
+
+async function testConnection() {
+    console.log("GLM-4.6 Connection Tester");
+
+    const apiKey = "d6127b23ffa74130bf6fbe3d98dab35a.o3cs6OuoHVuzn894";
+    console.log("Using provided key...");
+
+    const { endpoint } = await inquirer.prompt([{
+        type: 'list',
+        name: 'endpoint',
+        message: 'Select Endpoint to Test:',
+        choices: [
+            'https://open.bigmodel.cn/api/paas/v4/chat/completions',
+            'https://api.z.ai/api/paas/v4/chat/completions'
+        ]
+    }]);
+
+    const { model } = await inquirer.prompt([{
+        type: 'list',
+        name: 'model',
+        message: 'Select Model ID:',
+        choices: ['glm-4.6', 'glm-4', 'glm-4-plus']
+    }]);
+
+    console.log(`\nTesting ${model} @ ${endpoint} ...`);
+
+    try {
+        const response = await axios.post(
+            endpoint,
+            {
+                model: model,
+                messages: [{ role: "user", content: "Hello, are you working?" }]
+            },
+            {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`
+                }
+            }
+        );
+        console.log("\n✅ SUCCESS!");
+        console.log("Response:", response.data.choices[0].message.content);
+    } catch (error: any) {
+        console.log("\n❌ FAILED");
+        console.log("Status:", error.response?.status);
+        console.log("Data:", JSON.stringify(error.response?.data, null, 2));
+    }
+}
+
+testConnection();

package/scripts/test_models.ts

@@ -0,0 +1,38 @@
+
+import axios from 'axios';
+
+async function testConnection() {
+    const apiKey = "d6127b23ffa74130bf6fbe3d98dab35a.o3cs6OuoHVuzn894";
+    const endpoint = "https://open.bigmodel.cn/api/paas/v4/chat/completions";
+    const models = ['glm-4-plus', 'glm-4', 'glm-4-air'];
+
+    console.log("Testing models...");
+
+    for (const model of models) {
+        console.log(`\n--- Testing ${model} ---`);
+        try {
+            const response = await axios.post(
+                endpoint,
+                {
+                    model: model,
+                    messages: [{ role: "user", content: "Hi" }]
+                },
+                {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${apiKey}`
+                    }
+                }
+            );
+            console.log("✅ SUCCESS!");
+            console.log("Response:", response.data.choices[0].message.content);
+            return; // Exit on first success
+        } catch (error: any) {
+            console.log("❌ FAILED");
+            // console.log("Status:", error.response?.status);
+            console.log("Error:", error.response?.data?.error?.message || error.message);
+        }
+    }
+}
+
+testConnection();