@indiccoder/mentis-cli 1.0.3

package/dist/mcp/McpClient.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = void 0;
+const JsonRpcClient_1 = require("./JsonRpcClient");
+class McpClient {
+    constructor(command, args) {
+        this.serverName = 'unknown';
+        this.rpc = new JsonRpcClient_1.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() {
+        const result = await this.rpc.sendRequest('tools/list');
+        const mcpTools = result.tools || [];
+        return mcpTools.map((t) => new McpToolAdapter(this, t));
+    }
+    async callTool(name, args) {
+        return this.rpc.sendRequest('tools/call', {
+            name,
+            arguments: args,
+        });
+    }
+    disconnect() {
+        this.rpc.disconnect();
+    }
+}
+exports.McpClient = McpClient;
+class McpToolAdapter {
+    constructor(client, toolDef) {
+        this.client = client;
+        this.name = toolDef.name;
+        this.description = toolDef.description || '';
+        this.parameters = toolDef.inputSchema || {};
+    }
+    async execute(args) {
+        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) => c.text).join('\n');
+        }
+        return JSON.stringify(result);
+    }
+}

package/dist/repl/PersistentShell.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentShell = void 0;
+const child_process_1 = require("child_process");
+const os_1 = __importDefault(require("os"));
+class PersistentShell {
+    constructor() {
+        this.process = null;
+        this.buffer = '';
+        this.delimiter = 'MENTIS_SHELL_DELIMITER';
+        this.resolveCallback = null;
+        this.rejectCallback = null;
+        // Lazy init: Do not spawn here.
+    }
+    initialize() {
+        if (this.process)
+            return;
+        const shell = os_1.default.platform() === 'win32' ? 'powershell.exe' : 'bash';
+        const args = os_1.default.platform() === 'win32' ? ['-NoLogo', '-NoExit', '-Command', '-'] : [];
+        this.process = (0, child_process_1.spawn)(shell, args, {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        this.process.stdout.on('data', (data) => this.handleOutput(data));
+        this.process.stderr.on('data', (data) => this.handleOutput(data));
+        this.process.on('error', (err) => {
+            console.error('Shell process error:', err);
+        });
+        this.process.on('exit', (code) => {
+            if (code !== 0) {
+                console.warn(`Shell process exited with code ${code}`);
+            }
+            this.process = null; // Reset on exit
+        });
+    }
+    handleOutput(data) {
+        const chunk = data.toString();
+        this.buffer += chunk;
+        if (this.buffer.includes(this.delimiter)) {
+            const output = this.buffer.replace(this.delimiter, '').trim();
+            if (this.resolveCallback) {
+                this.resolveCallback(output);
+                this.resolveCallback = null;
+                this.rejectCallback = null;
+            }
+            this.buffer = '';
+        }
+    }
+    async execute(command) {
+        this.initialize(); // Ensure shell is running
+        if (this.resolveCallback) {
+            throw new Error('Shell is busy execution another command.');
+        }
+        if (!this.process) {
+            throw new Error('Failed to initialize shell process.');
+        }
+        return new Promise((resolve, reject) => {
+            this.resolveCallback = resolve;
+            this.rejectCallback = reject;
+            this.buffer = '';
+            const cleanCommand = command.replace(/\n/g, '; ');
+            const fullCommand = `${cleanCommand}; echo "${this.delimiter}"\n`;
+            this.process?.stdin.write(fullCommand);
+        });
+    }
+    kill() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+}
+exports.PersistentShell = PersistentShell;