@indiccoder/mentis-cli 1.0.3

package/src/tools/FileTools.ts

@@ -0,0 +1,89 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { Tool } from './Tool';
+
+export class WriteFileTool implements Tool {
+    name = 'write_file';
+    description = 'Write content to a file. Overwrites if exists. Creates directories if needed.';
+    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: { filePath: string; content: string }): Promise<string> {
+        try {
+            const absolutePath = path.resolve(args.filePath);
+            await fs.ensureDir(path.dirname(absolutePath));
+            await fs.writeFile(absolutePath, args.content, 'utf-8');
+            return `Successfully wrote to ${args.filePath}`;
+        } catch (error: any) {
+            return `Error writing file: ${error.message}`;
+        }
+    }
+}
+
+export class ReadFileTool implements Tool {
+    name = 'read_file';
+    description = 'Read content from a file.';
+    parameters = {
+        type: 'object',
+        properties: {
+            filePath: {
+                type: 'string',
+                description: 'The path to the file to read',
+            },
+        },
+        required: ['filePath'],
+    };
+
+    async execute(args: { filePath: string }): Promise<string> {
+        try {
+            const absolutePath = path.resolve(args.filePath);
+            if (!await fs.pathExists(absolutePath)) {
+                return `Error: File not found at ${args.filePath}`;
+            }
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            return content;
+        } catch (error: any) {
+            return `Error reading file: ${error.message}`;
+        }
+    }
+}
+
+export class ListDirTool implements Tool {
+    name = 'list_dir';
+    description = 'List files and directories in a path.';
+    parameters = {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'The directory path to list',
+            },
+        },
+        required: ['path'],
+    };
+
+    async execute(args: { path: string }): Promise<string> {
+        try {
+            const targetPath = path.resolve(args.path);
+            if (!await fs.pathExists(targetPath)) {
+                return `Error: Directory not found at ${args.path}`;
+            }
+            const files = await fs.readdir(targetPath);
+            return files.join('\n');
+        } catch (error: any) {
+            return `Error listing directory: ${error.message}`;
+        }
+    }
+}

package/src/tools/GitTools.ts

@@ -0,0 +1,113 @@
+import { Tool } from './Tool';
+import { exec } from 'child_process';
+import util from 'util';
+
+const execAsync = util.promisify(exec);
+
+export class GitStatusTool implements Tool {
+    name = 'git_status';
+    description = 'Check the status of the git repository.';
+    parameters = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+
+    async execute(args: any): Promise<string> {
+        try {
+            const { stdout } = await execAsync('git status');
+            return stdout;
+        } catch (error: any) {
+            return `Error running git status: ${error.message}`;
+        }
+    }
+}
+
+export class GitDiffTool implements Tool {
+    name = 'git_diff';
+    description = 'Show changes in the git repository.';
+    parameters = {
+        type: 'object',
+        properties: {
+            cached: {
+                type: 'boolean',
+                description: 'Show cached (staged) changes.'
+            }
+        },
+        required: []
+    };
+
+    async execute(args: { cached?: boolean }): Promise<string> {
+        try {
+            const cmd = args.cached ? 'git diff --cached' : 'git diff';
+            const { stdout } = await execAsync(cmd);
+            return stdout || 'No changes found.';
+        } catch (error: any) {
+            return `Error running git diff: ${error.message}`;
+        }
+    }
+}
+
+export class GitCommitTool implements Tool {
+    name = 'git_commit';
+    description = 'Commit changes to the git repository.';
+    parameters = {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'The commit message.'
+            }
+        },
+        required: ['message']
+    };
+
+    async execute(args: { message: string }): Promise<string> {
+        try {
+            // Escape double quotes in message
+            const safeMessage = args.message.replace(/"/g, '\\"');
+            const { stdout } = await execAsync(`git commit -m "${safeMessage}"`);
+            return stdout;
+        } catch (error: any) {
+            return `Error running git commit: ${error.message}`;
+        }
+    }
+}
+
+export class GitPushTool implements Tool {
+    name = 'git_push';
+    description = 'Push changes to the remote repository.';
+    parameters = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+
+    async execute(args: any): Promise<string> {
+        try {
+            const { stdout, stderr } = await execAsync('git push');
+            return stdout + (stderr ? `\nStderr: ${stderr}` : '');
+        } catch (error: any) {
+            return `Error running git push: ${error.message}`;
+        }
+    }
+}
+
+export class GitPullTool implements Tool {
+    name = 'git_pull';
+    description = 'Pull changes from the remote repository.';
+    parameters = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+
+    async execute(args: any): Promise<string> {
+        try {
+            const { stdout } = await execAsync('git pull');
+            return stdout;
+        } catch (error: any) {
+            return `Error running git pull: ${error.message}`;
+        }
+    }
+}

package/src/tools/PersistentShellTool.ts

@@ -0,0 +1,32 @@
+import { Tool } from './Tool';
+import { PersistentShell } from '../repl/PersistentShell';
+
+export class PersistentShellTool implements Tool {
+    name = 'run_shell';
+    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.';
+    parameters = {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The shell command to execute.'
+            }
+        },
+        required: ['command']
+    };
+
+    private shell: PersistentShell;
+
+    constructor(shell: PersistentShell) {
+        this.shell = shell;
+    }
+
+    async execute(args: { command: string }): Promise<string> {
+        try {
+            const output = await this.shell.execute(args.command);
+            return output || 'Command executed with no output.';
+        } catch (error: any) {
+            return `Error executing command: ${error.message}`;
+        }
+    }
+}

package/src/tools/SearchTools.ts

@@ -0,0 +1,74 @@
+import { Tool } from './Tool';
+import { exec } from 'child_process';
+import util from 'util';
+import path from 'path';
+
+const execAsync = util.promisify(exec);
+
+export class SearchFileTool implements Tool {
+    name = 'search_files';
+    description = 'Search for a string pattern in files within the current directory recursively.';
+    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: { query: string, path?: string }): Promise<string> {
+        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: any) {
+            // grep returns exit code 1 if not found, distinct from error
+            if (error.code === 1) return 'No matches found.';
+            return `Error searching: ${error.message}`;
+        }
+    }
+}
+
+export class RunShellTool implements Tool {
+    name = 'run_shell';
+    description = 'Execute a shell command. Use this for running tests, build scripts, or git commands.';
+    parameters = {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The shell command to execute.'
+            }
+        },
+        required: ['command']
+    };
+
+    async execute(args: { command: string }): Promise<string> {
+        // 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: any) {
+            return `Error executing command: ${error.message}\nSTDOUT: ${error.stdout}\nSTDERR: ${error.stderr}`;
+        }
+    }
+}

package/src/tools/Tool.ts

@@ -0,0 +1,6 @@
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: object;
+    execute(args: any): Promise<string>;
+}

package/src/tools/WebSearchTool.ts

@@ -0,0 +1,63 @@
+import { Tool } from './Tool';
+import { search } from 'duck-duck-scrape';
+import chalk from 'chalk';
+
+export class WebSearchTool implements Tool {
+    name = 'search_web';
+    description = 'Search the internet for documentation, libraries, or solutions to errors. Returns snippets of top results.';
+    parameters = {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'The search query.'
+            }
+        },
+        required: ['query']
+    };
+
+    async execute(args: { query: string }): Promise<string> {
+        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.dim(`  Searching Google for: "${args.query}"...`));
+
+                const googleResults: any[] = 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: any) {
+                console.log(chalk.dim(`  Google search failed (${googleError.message}), failing over to DuckDuckGo...`));
+            }
+
+            // Priority 2: DuckDuckGo Fallback
+            console.log(chalk.dim(`  Searching DuckDuckGo for: "${args.query}"...`));
+            const ddgResults = await 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: any) {
+            return `Error searching web: ${error.message}`;
+        }
+    }
+}

package/src/ui/UIManager.ts

@@ -0,0 +1,41 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import boxen from 'boxen';
+import chalk from 'chalk';
+
+export class UIManager {
+    public static displayLogo() {
+        console.clear();
+        const logoText = figlet.textSync('MENTIS', {
+            font: 'ANSI Shadow', // Use a block-like font
+            horizontalLayout: 'default',
+            verticalLayout: 'default',
+            width: 100,
+            whitespaceBreak: true,
+        });
+        console.log(gradient.pastel.multiline(logoText));
+        console.log(chalk.gray('  v1.0.0 - AI Coding Agent'));
+        console.log('');
+    }
+
+    public static displayWelcome() {
+        console.log(
+            boxen(
+                `${chalk.bold('Welcome to Mentis-CLI')}\n\n` +
+                `• Type ${chalk.cyan('/help')} for commands.\n` +
+                `• Type ${chalk.cyan('/config')} to setup your model.\n` +
+                `• Start typing to chat with your agent.`,
+                {
+                    padding: 1,
+                    margin: 1,
+                    borderStyle: 'round',
+                    borderColor: 'cyan',
+                }
+            )
+        );
+    }
+
+    public static printSeparator() {
+        console.log(chalk.gray('──────────────────────────────────────────────────'));
+    }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": [
+            "ES2020"
+        ],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
+}