@indiccoder/mentis-cli 1.0.3

package/src/checkpoint/CheckpointManager.ts

@@ -0,0 +1,61 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { ChatMessage } from '../llm/ModelInterface';
+
+export interface Checkpoint {
+    timestamp: number;
+    name: string;
+    history: ChatMessage[];
+    files: string[];
+}
+
+export class CheckpointManager {
+    private checkpointDir: string;
+
+    constructor() {
+        this.checkpointDir = path.join(os.homedir(), '.mentis', 'checkpoints');
+        fs.ensureDirSync(this.checkpointDir);
+    }
+
+    public save(name: string, history: ChatMessage[], files: string[]) {
+        const checkpoint: Checkpoint = {
+            timestamp: Date.now(),
+            name,
+            history,
+            files
+        };
+        const filePath = path.join(this.checkpointDir, `${name}.json`);
+        fs.writeJsonSync(filePath, checkpoint, { spaces: 2 });
+        return filePath;
+    }
+
+    public load(name: string): Checkpoint | null {
+        const filePath = path.join(this.checkpointDir, `${name}.json`);
+        if (fs.existsSync(filePath)) {
+            return fs.readJsonSync(filePath) as Checkpoint;
+        }
+        return null;
+    }
+
+    public list(): string[] {
+        if (!fs.existsSync(this.checkpointDir)) return [];
+        return fs.readdirSync(this.checkpointDir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => f.replace('.json', ''));
+    }
+
+    public delete(name: string): boolean {
+        const filePath = path.join(this.checkpointDir, `${name}.json`);
+        if (fs.existsSync(filePath)) {
+            fs.removeSync(filePath);
+            return true;
+        }
+        return false;
+    }
+
+    public exists(name: string): boolean {
+        const filePath = path.join(this.checkpointDir, `${name}.json`);
+        return fs.existsSync(filePath);
+    }
+}

package/src/config/ConfigManager.ts

@@ -0,0 +1,77 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+interface MentisConfig {
+    defaultProvider: string;
+    openai?: {
+        apiKey?: string;
+        baseUrl?: string;
+        model?: string;
+    };
+    ollama?: {
+        baseUrl?: string;
+        model?: string;
+    };
+    gemini?: {
+        apiKey?: string;
+        model?: string;
+    };
+    glm?: {
+        apiKey?: string;
+        model?: string; // e.g. glm-4
+        baseUrl?: string;
+    };
+
+}
+
+export class ConfigManager {
+    private configPath: string;
+    private config: MentisConfig;
+
+    constructor() {
+        this.configPath = path.join(os.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();
+    }
+
+    private loadConfig() {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                const fileContent = fs.readFileSync(this.configPath, 'utf-8');
+                this.config = { ...this.config, ...JSON.parse(fileContent) };
+            }
+        } catch (error) {
+            console.error('Error loading config:', error);
+        }
+    }
+
+    public saveConfig() {
+        try {
+            fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+        } catch (error) {
+            console.error('Error saving config:', error);
+        }
+    }
+
+    public getConfig(): MentisConfig {
+        return this.config;
+    }
+
+    public updateConfig(newConfig: Partial<MentisConfig>) {
+        this.config = { ...this.config, ...newConfig };
+        this.saveConfig();
+    }
+}

package/src/context/ContextManager.ts

@@ -0,0 +1,63 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export interface FileContext {
+    path: string;
+    content: string;
+}
+
+import { RepoMapper } from './RepoMapper';
+
+export class ContextManager {
+    private files: Map<string, string> = new Map();
+    private repoMapper: RepoMapper;
+
+    constructor() {
+        this.repoMapper = new RepoMapper(process.cwd());
+    }
+
+    public async addFile(filePath: string): Promise<string> {
+        try {
+            const absolutePath = path.resolve(process.cwd(), filePath);
+            if (!fs.existsSync(absolutePath)) {
+                throw new Error(`File not found: ${filePath}`);
+            }
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            this.files.set(absolutePath, content);
+            return `Added ${filePath} to context.`;
+        } catch (error: any) {
+            return `Error adding file: ${error.message}`;
+        }
+    }
+
+    public removeFile(filePath: string): string {
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        if (this.files.has(absolutePath)) {
+            this.files.delete(absolutePath);
+            return `Removed ${filePath} from context.`;
+        }
+        return `File not in context: ${filePath}`;
+    }
+
+    public clear(): void {
+        this.files.clear();
+    }
+
+    public getContextString(): string {
+        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.basename(filePath)} ---\n${content}\n\n`;
+            }
+        }
+
+        return context;
+    }
+
+    public getFiles(): string[] {
+        return Array.from(this.files.keys());
+    }
+}

package/src/context/RepoMapper.ts

@@ -0,0 +1,119 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execSync } from 'child_process';
+
+export class RepoMapper {
+    private rootDir: string;
+    private ignorePatterns: Set<string>;
+
+    constructor(rootDir: string) {
+        this.rootDir = rootDir;
+        this.ignorePatterns = new Set(['.git', 'node_modules', 'dist', 'coverage', '.DS_Store']);
+    }
+
+    public generateTree(): string {
+        try {
+            // Try using git first for speed
+            const stdout = 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, '');
+        }
+    }
+
+    private buildTreeFromPaths(paths: string[]): string {
+        const tree: any = {};
+
+        // 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, '');
+    }
+
+    private renderTree(node: any, indent: string): string {
+        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;
+    }
+
+    private walk(currentPath: string, indent: string): string {
+        try {
+            const files = fs.readdirSync(currentPath);
+            let result = '';
+
+            // Cache stats to avoid repeated calls during sort
+            const fileStats = files.map(file => {
+                try {
+                    return {
+                        name: file,
+                        isDir: fs.statSync(path.join(currentPath, file)).isDirectory()
+                    };
+                } catch {
+                    return null;
+                }
+            }).filter(f => f) as { name: string, isDir: boolean }[];
+
+            // 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.join(currentPath, fileObj.name), indent + childIndent);
+                }
+            });
+
+            return result;
+        } catch (e) {
+            return `${indent}Error reading directory: ${e}\n`;
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { ReplManager } from './repl/ReplManager';
+
+async function main() {
+    const repl = new ReplManager();
+    await repl.start();
+}
+
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/src/llm/ModelInterface.ts

@@ -0,0 +1,47 @@
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool'; // Added 'tool' role
+    content: string | null; // Content can be null for tool calls
+    tool_calls?: ToolCall[];
+    tool_call_id?: string; // For tool role messages
+    name?: string; // For tool role messages
+}
+
+export interface ChatResponse {
+    content: string;
+    tool_calls?: ToolCall[];
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+
+export interface ModelResponse {
+    content: string | null;
+    tool_calls?: ToolCall[];
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: object;
+    };
+}
+
+export interface ModelClient {
+    chat(messages: ChatMessage[], tools?: ToolDefinition[], signal?: AbortSignal): Promise<ModelResponse>;
+}

package/src/llm/OpenAIClient.ts

@@ -0,0 +1,64 @@
+import axios from 'axios';
+import { ModelClient, ChatMessage, ModelResponse, ToolDefinition } from './ModelInterface';
+
+export class OpenAIClient implements ModelClient {
+    private baseUrl: string;
+    private apiKey: string;
+    private model: string;
+
+    constructor(baseUrl: string, apiKey: string, model: string) {
+        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+
+    async chat(messages: ChatMessage[], tools?: ToolDefinition[], signal?: AbortSignal): Promise<ModelResponse> {
+        try {
+            const requestBody: any = {
+                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.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: any) {
+            if (axios.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;
+        }
+    }
+}

package/src/mcp/JsonRpcClient.ts

@@ -0,0 +1,103 @@
+import { spawn, ChildProcess } from 'child_process';
+import * as readline from 'readline';
+
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    method: string;
+    params?: any;
+    id?: number | string;
+}
+
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+
+export class JsonRpcClient {
+    private process: ChildProcess;
+    private sequence = 0;
+    private pendingRequests = new Map<number | string, { resolve: Function; reject: Function }>();
+
+    constructor(command: string, args: string[]) {
+        this.process = 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));
+    }
+
+    private handleMessage(line: string) {
+        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);
+        }
+    }
+
+    public async sendRequest(method: string, params?: any): Promise<any> {
+        const id = this.sequence++;
+        const request: JsonRpcRequest = {
+            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);
+            }
+        });
+    }
+
+    public sendNotification(method: string, params?: any) {
+        if (!this.process.stdin) return;
+        const notification: JsonRpcRequest = {
+            jsonrpc: '2.0',
+            method,
+            params,
+        };
+        this.process.stdin.write(JSON.stringify(notification) + '\n');
+    }
+
+    public disconnect() {
+        this.process.kill();
+    }
+}

package/src/mcp/McpClient.ts

@@ -0,0 +1,75 @@
+import { JsonRpcClient } from './JsonRpcClient';
+import { Tool } from '../tools/Tool';
+
+export class McpClient {
+    private rpc: JsonRpcClient;
+    public serverName: string = 'unknown';
+
+    constructor(command: string, args: string[]) {
+        this.rpc = new JsonRpcClient(command, args);
+    }
+
+    async initialize() {
+        const result = await this.rpc.sendRequest('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: {
+                name: 'mentis-cli',
+                version: '1.0.0',
+            },
+        });
+
+        this.serverName = result.serverInfo.name;
+
+        // Notify initialized
+        this.rpc.sendNotification('notifications/initialized');
+        return result;
+    }
+
+    async listTools(): Promise<Tool[]> {
+        const result = await this.rpc.sendRequest('tools/list');
+        const mcpTools = result.tools || [];
+
+        return mcpTools.map((t: any) => new McpToolAdapter(this, t));
+    }
+
+    async callTool(name: string, args: any): Promise<any> {
+        return this.rpc.sendRequest('tools/call', {
+            name,
+            arguments: args,
+        });
+    }
+
+    disconnect() {
+        this.rpc.disconnect();
+    }
+}
+
+class McpToolAdapter implements Tool {
+    private client: McpClient;
+    public name: string;
+    public description: string;
+    public parameters: any;
+
+    constructor(client: McpClient, toolDef: any) {
+        this.client = client;
+        this.name = toolDef.name;
+        this.description = toolDef.description || '';
+        this.parameters = toolDef.inputSchema || {};
+    }
+
+    async execute(args: any): Promise<string> {
+        const result = await this.client.callTool(this.name, args);
+        // MCP returns { content: [ { type: 'text', text: '...' } ], isError: boolean }
+        if (result.isError) {
+            throw new Error('MCP Tool Error');
+        }
+
+        // Extract text content
+        if (result.content && Array.isArray(result.content)) {
+            return result.content.map((c: any) => c.text).join('\n');
+        }
+
+        return JSON.stringify(result);
+    }
+}