matex-cli 1.2.42 → 1.2.43

package/src/utils/mcp-server.ts

@@ -0,0 +1,388 @@
+/**
+ * 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.`;
+    }
+}

package/src/utils/repo-mapper.ts

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import chalk from 'chalk';
 import { AgentOrchestrator } from './agent-orchestrator';
 
 export interface RepoNode {
@@ -35,18 +36,28 @@ export class RepoMapper {
         // 1. Identify Entry Points
         const entryPoints = ['README.md', 'package.json', 'index.ts', 'App.tsx', 'main.go', 'requirements.txt', 'index.html', 'style.css'];
 
+        let delayMs = 15; // Animation delay
+
+        AgentOrchestrator.speak('System', `God-Mode Research: Injecting scanners into ${this.rootPath}...`);
+        console.log();
+
         for (const file of entryPoints) {
             const fullPath = path.join(this.rootPath, file);
             if (fs.existsSync(fullPath)) {
                 try {
                     const content = fs.readFileSync(fullPath, 'utf-8').slice(0, 5000); // 5KB limit
                     this.fileContents.set(file, content);
+                    console.log(chalk.hex('#4ade80')(`  ⚡ [Core Injection] `) + chalk.gray(`Mapped entry node: `) + chalk.white.bold(file));
                 } catch (e) { }
             }
         }
 
+        console.log(chalk.cyan(`  🔍 [Deep Scan] `) + chalk.gray(`Mapping topology...`));
         const tree = this.scanDirectory(this.rootPath, 0);
 
+        console.log(chalk.hex('#FF6B00')(`  🔥 [Knowledge Graph] `) + chalk.gray(`Extracted ${this.fileContents.size} semantic nodes from source.`));
+        console.log();
+
         // Build the final map
         let finalMap = `--- ABSOLUTE WORKING DIRECTORY ---\n${this.rootPath}\n\n`;
 

package/src/utils/spinner.ts

@@ -4,38 +4,47 @@ import chalk from 'chalk';
 export class Spinner {
     private spinner: Ora | null = null;
 
+    /**
+     * Start the premium MATEX loading spinner
+     */
     start(text: string): void {
         this.spinner = ora({
-            text: chalk.cyan(text),
+            text: chalk.hex('#D97757').bold(text),
             color: 'cyan',
-            spinner: 'dots',
+            spinner: {
+                interval: 80,
+                frames: [
+                    '⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'
+                ].map(f => chalk.cyan(f)) // Inject cyan into each frame
+            },
+            prefixText: chalk.bgHex('#1E1E1E').green(' ⚡ MATEX_SWARM_ACTIVE ') + ' ',
         }).start();
     }
 
     succeed(text?: string): void {
         if (this.spinner) {
-            this.spinner.succeed(text ? chalk.green(text) : undefined);
+            this.spinner.succeed(chalk.green('✓ ') + chalk.white.bold(text || 'Done'));
             this.spinner = null;
         }
     }
 
     fail(text?: string): void {
         if (this.spinner) {
-            this.spinner.fail(text ? chalk.red(text) : undefined);
+            this.spinner.fail(chalk.red('✗ ') + chalk.white.bold(text || 'Failed'));
             this.spinner = null;
         }
     }
 
     warn(text?: string): void {
         if (this.spinner) {
-            this.spinner.warn(text ? chalk.yellow(text) : undefined);
+            this.spinner.warn(chalk.yellow('⚠ ') + chalk.white(text || 'Warning'));
             this.spinner = null;
         }
     }
 
     info(text?: string): void {
         if (this.spinner) {
-            this.spinner.info(text ? chalk.blue(text) : undefined);
+            this.spinner.info(chalk.blue('ℹ ') + chalk.white(text || 'Info'));
             this.spinner = null;
         }
     }
@@ -49,7 +58,7 @@ export class Spinner {
 
     updateText(text: string): void {
         if (this.spinner) {
-            this.spinner.text = chalk.cyan(text);
+            this.spinner.text = chalk.hex('#D97757').bold(text);
         }
     }
 }

package/src/utils/tui.ts

@@ -105,17 +105,64 @@ export class TUI {
     }
 
     /**
-     * Draw a clean summary report
+     * Draw Ajay Vai's premium summary with a human chat bubble vibe
      */
     static drawSummaryBox(content: string) {
-        console.log('\n' + chalk.magenta.bold('== ✅ AJAY VAI\'S WORK SUMMARY =='));
+        const width = Math.min(process.stdout.columns || 80, 76);
+        const innerWidth = width - 6;
+        const magenta = chalk.hex('#ff69b4');
+        const pinkBright = chalk.hex('#ff99cc');
+        const pinkGlow = chalk.hex('#ffccee');
+
+        console.log();
+        // Timestamp for chat realism
+        const time = new Date().toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' });
+        console.log(chalk.gray(`  ╭─ [${time}] ──────────────────────────────`));
+
+        // Header mimicking WhatsApp / iMessage chat interface
+        const headerText = '🚀 Ajay Vai';
+        const typingText = chalk.italic.gray('sent you a message');
+        console.log(`  │ ${magenta.bold(headerText)} ${typingText}`);
+
+        // Chat bubble top
+        console.log(pinkGlow(`  ╭${'─'.repeat(width - 4)}╮`));
+
+        // Content with chat bubble formatting
         const lines = content.split('\n');
         lines.forEach(line => {
-            if (line.trim()) {
-                console.log(chalk.white(line.trim()));
-            }
+            if (!line.trim()) return;
+            const trimmed = line.trim();
+
+            // Word wrap
+            const words = trimmed.split(' ');
+            let currentLine = '';
+            const wrappedLines: string[] = [];
+
+            words.forEach(word => {
+                if ((currentLine + ' ' + word).trim().length <= innerWidth) {
+                    currentLine = currentLine ? currentLine + ' ' + word : word;
+                } else {
+                    if (currentLine) wrappedLines.push(currentLine);
+                    currentLine = word.length > innerWidth ? word.substring(0, innerWidth) : word;
+                }
+            });
+            if (currentLine) wrappedLines.push(currentLine);
+
+            wrappedLines.forEach(wl => {
+                const linePad = Math.max(0, innerWidth - wl.length);
+                // Keep bullet formatting but tone down the robotic feel
+                if (wl.startsWith('- ') || wl.startsWith('• ') || wl.match(/^\d+\./)) {
+                    console.log(pinkGlow('  │ ') + magenta('• ') + chalk.white(wl.replace(/^[-•]\s*/, '').replace(/^\d+\.\s*/, '')) + ' '.repeat(Math.max(0, linePad - 2)) + pinkGlow(' │'));
+                } else {
+                    console.log(pinkGlow('  │ ') + chalk.white(wl) + ' '.repeat(linePad) + pinkGlow(' │'));
+                }
+            });
         });
-        console.log(chalk.magenta.bold('=================================\n'));
+
+        // Chat bubble bottom
+        console.log(pinkGlow(`  ╰${'─'.repeat(width - 4)}╯`));
+        console.log(chalk.gray(`  ╰──────────────────────────────────────────`));
+        console.log();
     }
 
     /**
@@ -131,7 +178,7 @@ export class TUI {
     }
 
     /**
-     * Draw a beautiful, compact internal dialogue container for the Swarm
+     * Draw a premium glowing dialogue container for Swarm agents
      */
     static drawSwarmDialogue(agent: string, message: string) {
         const isBigBro = agent.includes('Big Bro');
@@ -144,7 +191,20 @@ export class TUI {
                                 agent.includes('Nerd') ? chalk.hex('#06b6d4') :
                                     agent.includes('Chill') ? chalk.hex('#22c55e') :
                                         agent.includes('Lil') ? chalk.hex('#888888') :
-                                            chalk.green;
+                                            agent.includes('Narayan') ? chalk.green :
+                                                chalk.green;
+
+        // Glow color is a brighter version of the agent color
+        const glowColor = isBigBro ? chalk.hex('#FF9642') :
+            agent.includes('Ajay') ? chalk.hex('#ff77ff') :
+                agent.includes('Sunil') ? chalk.hex('#66aaff') :
+                    agent.includes('Sandip') ? chalk.hex('#ff99cc') :
+                        agent.includes('Bishal') ? chalk.hex('#ffee66') :
+                            agent.includes('Hype') ? chalk.hex('#ffe066') :
+                                agent.includes('Nerd') ? chalk.hex('#33ddee') :
+                                    agent.includes('Chill') ? chalk.hex('#66ff88') :
+                                        agent.includes('Lil') ? chalk.hex('#aaaaaa') :
+                                            chalk.hex('#66ff88');
 
         const icon = isBigBro ? '🔥' :
             agent.includes('Ajay') ? '🚀' :
@@ -154,19 +214,22 @@ export class TUI {
                             agent.includes('Hype') ? '🎉' :
                                 agent.includes('Nerd') ? '🤓' :
                                     agent.includes('Chill') ? '😎' :
-                                        agent.includes('Lil') ? '😰' : '🛡️';
+                                        agent.includes('Lil') ? '😰' :
+                                            agent.includes('Narayan') ? '🛡️' : '🛡️';
 
         const width = Math.min(process.stdout.columns || 80, 76);
         const innerWidth = width - 6;
 
-        // Top border
-        console.log(color(`  ┌${'─'.repeat(width - 4)}┐`));
-        // Header
+        // Top glow shimmer
+        console.log(glowColor(`  ░${'░'.repeat(width - 4)}░`));
+        // Top border with premium double-line
+        console.log(color(`  ╔${'═'.repeat(width - 4)}╗`));
+        // Header with agent name
         const headerText = `${icon} ${agent}`;
         const pad = Math.max(0, innerWidth - headerText.length);
-        console.log(color('  │ ') + color.bold(headerText) + ' '.repeat(pad) + color(' │'));
-        // Separator
-        console.log(color(`  ├${'─'.repeat(width - 4)}┤`));
+        console.log(color('  ║ ') + color.bold(headerText) + ' '.repeat(pad) + color(' ║'));
+        // Separator with dots for premium feel
+        console.log(color('  ╠') + glowColor('·'.repeat(width - 4)) + color('╣'));
 
         // Content lines with word wrap
         const words = message.split(' ');
@@ -185,11 +248,13 @@ export class TUI {
 
         wrappedLines.forEach(line => {
             const linePad = Math.max(0, innerWidth - line.length);
-            console.log(color('  │ ') + chalk.gray(line) + ' '.repeat(linePad) + color(' │'));
+            console.log(color('  ║ ') + chalk.white(line) + ' '.repeat(linePad) + color(' ║'));
         });
 
         // Bottom border
-        console.log(color(`  └${'─'.repeat(width - 4)}┘`));
+        console.log(color(`  ╚${'═'.repeat(width - 4)}╝`));
+        // Bottom glow shimmer
+        console.log(glowColor(`  ░${'░'.repeat(width - 4)}░`));
     }
 
     /**