matex-cli 1.2.81 → 1.2.84

package/src/utils/config.ts

@@ -1,124 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-export interface Config {
-    apiKey?: string;
-    defaultModel?: string;
-    baseURL?: string;
-}
-
-export class ConfigManager {
-    private configDir: string;
-    private configPath: string;
-
-    constructor() {
-        this.configDir = path.join(os.homedir(), '.matex');
-        this.configPath = path.join(this.configDir, 'config.json');
-
-        // Ensure config directory exists
-        if (!fs.existsSync(this.configDir)) {
-            fs.mkdirSync(this.configDir, { recursive: true });
-        }
-    }
-
-    /**
-     * Load config from file
-     */
-    private loadConfig(): Config {
-        if (!fs.existsSync(this.configPath)) {
-            return {};
-        }
-
-        try {
-            const data = fs.readFileSync(this.configPath, 'utf-8');
-            return JSON.parse(data);
-        } catch (error) {
-            return {};
-        }
-    }
-
-    /**
-     * Save config to file
-     */
-    private saveConfig(config: Config): void {
-        fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
-    }
-
-    /**
-     * Set API key
-     */
-    setAPIKey(apiKey: string): void {
-        const config = this.loadConfig();
-        config.apiKey = apiKey;
-        this.saveConfig(config);
-    }
-
-    /**
-     * Get API key
-     */
-    getAPIKey(): string | undefined {
-        return this.loadConfig().apiKey;
-    }
-
-    /**
-     * Set default model
-     */
-    setDefaultModel(model: string): void {
-        const config = this.loadConfig();
-        let normalizedModel = model.toLowerCase().trim().replace(/\s+/g, '');
-        if (normalizedModel === 'matexfree') {
-            normalizedModel = 'matex-free';
-        }
-        config.defaultModel = normalizedModel;
-        this.saveConfig(config);
-    }
-
-    /**
-     * Get default model
-     */
-    getDefaultModel(): string {
-        return this.loadConfig().defaultModel || 'matexcodex';
-    }
-
-    /**
-     * Set base URL
-     */
-    setBaseURL(url: string): void {
-        const config = this.loadConfig();
-        config.baseURL = url;
-        this.saveConfig(config);
-    }
-
-    /**
-     * Get base URL
-     */
-    getBaseURL(): string {
-        return this.loadConfig().baseURL || 'https://matexai-backend-550499663766.us-central1.run.app';
-    }
-
-    /**
-     * Get all config
-     */
-    getAll(): Config {
-        return this.loadConfig();
-    }
-
-    /**
-     * Clear all config
-     */
-    clear(): void {
-        if (fs.existsSync(this.configPath)) {
-            fs.unlinkSync(this.configPath);
-        }
-    }
-
-    /**
-     * Check if API key is set
-     */
-    hasAPIKey(): boolean {
-        return !!this.getAPIKey();
-    }
-}
-
-export const configManager = new ConfigManager();

package/src/utils/mcp-server.ts

@@ -1,388 +0,0 @@
-/**
- * MCP (Model Context Protocol) Server Manager
- * =============================================
- * Production-level MCP servers that give CLI agents the ability to:
- * - Read/write/search files on the local filesystem
- * - Execute shell commands
- * - Fetch web content (URL context)
- * - Search Google (via SearxNG or Brave)
- * - Access project context (repo map, git status)
- *
- * These tools are injected into agent system prompts so the AI
- * knows what capabilities it has and can request them.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import chalk from 'chalk';
-import https from 'https';
-import http from 'http';
-
-// ============================================================
-// TOOL DEFINITIONS (MCP-style JSON Schema)
-// ============================================================
-
-export interface MCPToolDefinition {
-    name: string;
-    description: string;
-    parameters: Record<string, any>;
-}
-
-export interface MCPToolResult {
-    success: boolean;
-    output?: string;
-    error?: string;
-}
-
-/**
- * All available MCP tools for CLI agents
- */
-export const MCP_TOOLS: MCPToolDefinition[] = [
-    {
-        name: 'read_file',
-        description: 'Read the full contents of a file at the given path.',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Absolute or relative file path' },
-                start_line: { type: 'number', description: 'Optional start line (1-indexed)' },
-                end_line: { type: 'number', description: 'Optional end line (1-indexed)' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'write_file',
-        description: 'Create or overwrite a file with the given content.',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'File path to write' },
-                content: { type: 'string', description: 'File content to write' },
-            },
-            required: ['path', 'content'],
-        },
-    },
-    {
-        name: 'list_directory',
-        description: 'List files and subdirectories at a given path.',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Directory path to list' },
-                recursive: { type: 'boolean', description: 'If true, list recursively (max depth 3)' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'search_files',
-        description: 'Search for a text pattern across files using grep.',
-        parameters: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string', description: 'Search pattern (regex supported)' },
-                path: { type: 'string', description: 'Directory or file to search in' },
-                include: { type: 'string', description: 'Glob pattern to filter files (e.g., "*.ts")' },
-            },
-            required: ['pattern', 'path'],
-        },
-    },
-    {
-        name: 'run_command',
-        description: 'Execute a shell command and return its output.',
-        parameters: {
-            type: 'object',
-            properties: {
-                command: { type: 'string', description: 'Shell command to execute' },
-                cwd: { type: 'string', description: 'Working directory for the command' },
-            },
-            required: ['command'],
-        },
-    },
-    {
-        name: 'fetch_url',
-        description: 'Fetch content from a URL and return it as text.',
-        parameters: {
-            type: 'object',
-            properties: {
-                url: { type: 'string', description: 'URL to fetch' },
-            },
-            required: ['url'],
-        },
-    },
-    {
-        name: 'git_status',
-        description: 'Get the current git status of the repository.',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Repository path' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'web_search',
-        description: 'Search the web using SearxNG or Brave Search API.',
-        parameters: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'Search query' },
-                num_results: { type: 'number', description: 'Number of results (default 5)' },
-            },
-            required: ['query'],
-        },
-    },
-];
-
-// ============================================================
-// TOOL EXECUTORS
-// ============================================================
-
-export class MCPServer {
-    private cwd: string;
-    private braveApiKey?: string;
-    private searxngUrl?: string;
-
-    constructor(cwd: string, options?: { braveApiKey?: string; searxngUrl?: string }) {
-        this.cwd = cwd;
-        this.braveApiKey = options?.braveApiKey;
-        this.searxngUrl = options?.searxngUrl;
-    }
-
-    /**
-     * Execute an MCP tool by name
-     */
-    async execute(toolName: string, args: Record<string, any>): Promise<MCPToolResult> {
-        try {
-            switch (toolName) {
-                case 'read_file': return this.readFile(args.path, args.start_line, args.end_line);
-                case 'write_file': return this.writeFile(args.path, args.content);
-                case 'list_directory': return this.listDirectory(args.path, args.recursive);
-                case 'search_files': return this.searchFiles(args.pattern, args.path, args.include);
-                case 'run_command': return this.runCommand(args.command, args.cwd);
-                case 'fetch_url': return await this.fetchUrl(args.url);
-                case 'git_status': return this.gitStatus(args.path);
-                case 'web_search': return await this.webSearch(args.query, args.num_results);
-                default: return { success: false, error: `Unknown tool: ${toolName}` };
-            }
-        } catch (err: any) {
-            return { success: false, error: err.message };
-        }
-    }
-
-    /**
-     * Read a file
-     */
-    private readFile(filePath: string, startLine?: number, endLine?: number): MCPToolResult {
-        const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(this.cwd, filePath);
-        if (!fs.existsSync(resolved)) {
-            return { success: false, error: `File not found: ${resolved}` };
-        }
-        const content = fs.readFileSync(resolved, 'utf-8');
-        if (startLine || endLine) {
-            const lines = content.split('\n');
-            const start = Math.max(0, (startLine || 1) - 1);
-            const end = Math.min(lines.length, endLine || lines.length);
-            return { success: true, output: lines.slice(start, end).join('\n') };
-        }
-        // Cap output at 500 lines
-        const lines = content.split('\n');
-        if (lines.length > 500) {
-            return { success: true, output: lines.slice(0, 500).join('\n') + `\n\n... (${lines.length - 500} more lines truncated)` };
-        }
-        return { success: true, output: content };
-    }
-
-    /**
-     * Write a file (creates directories if needed)
-     */
-    private writeFile(filePath: string, content: string): MCPToolResult {
-        const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(this.cwd, filePath);
-        const dir = path.dirname(resolved);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(resolved, content, 'utf-8');
-        return { success: true, output: `File written: ${resolved}` };
-    }
-
-    /**
-     * List directory contents
-     */
-    private listDirectory(dirPath: string, recursive?: boolean): MCPToolResult {
-        const resolved = path.isAbsolute(dirPath) ? dirPath : path.resolve(this.cwd, dirPath);
-        if (!fs.existsSync(resolved)) {
-            return { success: false, error: `Directory not found: ${resolved}` };
-        }
-        try {
-            const maxDepth = recursive ? 3 : 1;
-            const result = execSync(
-                `find "${resolved}" -maxdepth ${maxDepth} -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' | head -200`,
-                { encoding: 'utf-8', timeout: 5000 }
-            ).trim();
-            return { success: true, output: result };
-        } catch {
-            return { success: false, error: `Failed to list directory: ${resolved}` };
-        }
-    }
-
-    /**
-     * Search files with grep
-     */
-    private searchFiles(pattern: string, searchPath: string, include?: string): MCPToolResult {
-        const resolved = path.isAbsolute(searchPath) ? searchPath : path.resolve(this.cwd, searchPath);
-        try {
-            const includeFlag = include ? `--include='${include}'` : '';
-            const result = execSync(
-                `grep -rn ${includeFlag} --color=never "${pattern}" "${resolved}" 2>/dev/null | head -50`,
-                { encoding: 'utf-8', timeout: 10000 }
-            ).trim();
-            return { success: true, output: result || 'No matches found.' };
-        } catch {
-            return { success: true, output: 'No matches found.' };
-        }
-    }
-
-    /**
-     * Run a shell command
-     */
-    private runCommand(command: string, cwd?: string): MCPToolResult {
-        const workDir = cwd ? (path.isAbsolute(cwd) ? cwd : path.resolve(this.cwd, cwd)) : this.cwd;
-        try {
-            const result = execSync(command, {
-                encoding: 'utf-8',
-                cwd: workDir,
-                timeout: 30000,
-                env: { ...process.env, FORCE_COLOR: '0' },
-            }).trim();
-            return { success: true, output: result || '(No output)' };
-        } catch (err: any) {
-            return { success: false, error: err.stderr || err.message };
-        }
-    }
-
-    /**
-     * Fetch URL content
-     */
-    private async fetchUrl(url: string): Promise<MCPToolResult> {
-        return new Promise((resolve) => {
-            const client = url.startsWith('https') ? https : http;
-            const req = client.get(url, { timeout: 10000 }, (res) => {
-                let data = '';
-                res.on('data', (chunk: Buffer) => { data += chunk.toString(); });
-                res.on('end', () => {
-                    // Strip HTML tags for readability, cap at 5000 chars
-                    const text = data.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
-                    resolve({
-                        success: true,
-                        output: text.length > 5000 ? text.substring(0, 5000) + '...' : text,
-                    });
-                });
-            });
-            req.on('error', (err: Error) => resolve({ success: false, error: err.message }));
-            req.on('timeout', () => { req.destroy(); resolve({ success: false, error: 'Request timed out' }); });
-        });
-    }
-
-    /**
-     * Git status
-     */
-    private gitStatus(repoPath: string): MCPToolResult {
-        const resolved = path.isAbsolute(repoPath) ? repoPath : path.resolve(this.cwd, repoPath);
-        try {
-            const status = execSync('git status --short', { encoding: 'utf-8', cwd: resolved }).trim();
-            const branch = execSync('git branch --show-current', { encoding: 'utf-8', cwd: resolved }).trim();
-            const lastCommit = execSync('git log -1 --oneline', { encoding: 'utf-8', cwd: resolved }).trim();
-            return {
-                success: true,
-                output: `Branch: ${branch}\nLast commit: ${lastCommit}\n\nChanged files:\n${status || '(clean)'}`,
-            };
-        } catch (err: any) {
-            return { success: false, error: 'Not a git repository or git not available.' };
-        }
-    }
-
-    /**
-     * Web search via SearxNG or Brave
-     */
-    private async webSearch(query: string, numResults: number = 5): Promise<MCPToolResult> {
-        // Try SearxNG first
-        if (this.searxngUrl) {
-            try {
-                const url = `${this.searxngUrl}/search?q=${encodeURIComponent(query)}&format=json&engines=google,bing&results=${numResults}`;
-                const result = await this.fetchUrl(url);
-                if (result.success && result.output) {
-                    try {
-                        const data = JSON.parse(result.output);
-                        const results = (data.results || []).slice(0, numResults).map((r: any, i: number) =>
-                            `${i + 1}. ${r.title}\n   ${r.url}\n   ${(r.content || '').substring(0, 200)}`
-                        ).join('\n\n');
-                        return { success: true, output: results || 'No results found.' };
-                    } catch { /* fall through */ }
-                }
-            } catch { /* fall through to Brave */ }
-        }
-
-        // Fallback: Brave Search
-        if (this.braveApiKey) {
-            return new Promise((resolve) => {
-                const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${numResults}`;
-                const req = https.get(url, {
-                    headers: {
-                        'Accept': 'application/json',
-                        'X-Subscription-Token': this.braveApiKey!,
-                    },
-                    timeout: 10000,
-                }, (res) => {
-                    let data = '';
-                    res.on('data', (chunk: Buffer) => { data += chunk.toString(); });
-                    res.on('end', () => {
-                        try {
-                            const parsed = JSON.parse(data);
-                            const results = (parsed.web?.results || []).slice(0, numResults).map((r: any, i: number) =>
-                                `${i + 1}. ${r.title}\n   ${r.url}\n   ${(r.description || '').substring(0, 200)}`
-                            ).join('\n\n');
-                            resolve({ success: true, output: results || 'No results found.' });
-                        } catch {
-                            resolve({ success: false, error: 'Failed to parse search results.' });
-                        }
-                    });
-                });
-                req.on('error', (err: Error) => resolve({ success: false, error: err.message }));
-            });
-        }
-
-        return { success: false, error: 'No search backend configured. Set BRAVE_SEARCH_API_KEY or SEARXNG_URL.' };
-    }
-
-    /**
-     * Generate the MCP tool capabilities section for system prompts
-     */
-    static getToolsPromptSection(): string {
-        return `### 🔌 MCP TOOLS (Model Context Protocol):
-You have access to the following production-level tools via MCP. Use them to navigate, read, write, and search:
-
-| Tool | Description |
-|------|-------------|
-| \`read_file(path, start_line?, end_line?)\` | Read file contents (supports line ranges) |
-| \`write_file(path, content)\` | Create or overwrite a file |
-| \`list_directory(path, recursive?)\` | List files and subdirectories |
-| \`search_files(pattern, path, include?)\` | Search for text patterns (grep) |
-| \`run_command(command, cwd?)\` | Execute a shell command |
-| \`fetch_url(url)\` | Fetch web content from a URL |
-| \`git_status(path)\` | Get git status, branch, and last commit |
-| \`web_search(query, num_results?)\` | Search the web via SearxNG/Brave |
-
-**HOW TO USE:** When you need to use a tool, output it as a shell command:
-- To read: \`head -50 path/to/file\` or \`cat path/to/file\`
-- To search: \`grep -rn "pattern" path/\`
-- To list: \`ls -la path/\` or \`find path/ -maxdepth 2\`
-- To execute: wrap in \`\`\`bash code blocks
-- To fetch URL: \`curl -s "url" | head -100\`
-
-These tools allow you to **navigate any file/directory** on the system using your own brain to decide where to go.`;
-    }
-}