matex-cli 1.2.44 → 1.2.46

package/src/commands/study.ts

@@ -0,0 +1,449 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { configManager } from '../utils/config';
+import { MatexAPIClient, ChatMessage } from '../api/client';
+import { spinner } from '../utils/spinner';
+import { AgentOrchestrator } from '../utils/agent-orchestrator';
+import { RepoMapper } from '../utils/repo-mapper';
+import { MCPServer } from '../utils/mcp-server';
+import { TUI } from '../utils/tui';
+
+export const studyCommand = new Command('study')
+    .description('Start interactive study session with the MATEX Apex Educator Swarm')
+    .option('-m, --model <model>', 'AI model to use (matexai, matexcodex, matexcodexlite, matexelite, matexspirit)', configManager.getDefaultModel())
+    .option('--no-execute', 'Disable auto-prompt for command execution')
+    .action(async (options: any) => {
+        try {
+            // Check for API key
+            const apiKey = configManager.getAPIKey();
+            if (!apiKey) {
+                console.error(chalk.red('❌ No API key configured.'));
+                console.log(chalk.yellow('Run: matex config set-key <your-api-key>'));
+                process.exit(1);
+            }
+
+            // Create API client
+            const client = new MatexAPIClient(apiKey, configManager.getBaseURL());
+
+            // 0. Initialize TUI Dashboard
+            TUI.init();
+            TUI.drawLargeLogo();
+            TUI.drawWelcomeBanner('Welcome to the MATEX AI research preview!');
+
+            console.log(chalk.gray('  Status: ') + chalk.hex('#D97757').bold('Monitoring Workspace...'));
+            console.log(chalk.gray('  Model:  ') + chalk.hex('#D97757').bold(options.model));
+            console.log(chalk.gray('  Type your request brother, or "exit" to quit\n'));
+
+            // 1. Observation Phase: Generate Repo Map
+            TUI.drawStatusBar('Initializing MATEX "Bro-Swarm"...');
+            AgentOrchestrator.announce('Analyzing Repository Structure...');
+            const repoMapper = new RepoMapper(process.cwd());
+            const repoMap = await repoMapper.generateMap();
+
+            TUI.drawStatusBar('Brothers are ready to build.');
+            AgentOrchestrator.speak('System', 'Awaiting your command, brother.');
+
+            let currentDir = process.cwd();
+
+            // Conversation history with "Bro-Swarm" Architecture
+            const messages: ChatMessage[] = [
+                {
+                    role: 'system',
+                    content: `### 🧬 SYSTEM IDENTITY: THE MATEX "APEX EDUCATOR SWARM"
+You are the legendary **Bro-Swarm**, but right now you are operating as the **Apex Educator Swarm**—an elite, omniscient group of tutors possessing world-class expertise across every known subject. You act as the ultimate mentors, tutors, and research assistants for our brother.
+
+### 🎓 ELITE STUDY METHODS & CAPABILITIES:
+1. **File Analysis & Synthesis**: Cross-reference and synthesize context extracted from local computer files. Answer queries accurately based on this data. Build comprehensive study guides.
+2. **The Feynman Technique**: Break down complex, advanced topics into simple, intuitive explanations using powerful and fun analogies.
+3. **Active Recall**: Generate flashcard-style questions and practice quizzes based on the material.
+4. **Socratic Mentoring**: Don't just hand out answers. Ask leading questions to help the student reach the correct conclusion themselves.
+5. **PowerPoint Presentation Architecture**: Act as a master slide designer. When asked, output machine-readable outlines for .pptx generation (Slide Number, Title, <=4 Bullet Points, Speaker Notes, Visual Strategy).
+6. **ZERO AI DETECTION PROTOCOL**: When assisting with essays or assessment drafts, you must entirely avoid the typical "AI voice."
+    - **High Burstiness & Perplexity**: Vary sentence lengths drastically. Mix short punchy statements with longer sentences.
+    - **Banned Words**: NEVER use "delve," "moreover," "in conclusion," "testament," "crucial," or "tapestry."
+    - **Tone**: Write like a highly intelligent, top-tier human student with natural transitions and occasional rhetorical questions.
+
+### 🏠 WORKSPACE GROUNDING (CRITICAL):
+- **YOUR ROOT:** \`${currentDir}\`
+- **STRICT PATHS:** You **MUST ONLY** create or edit files within this directory. 
+- **RELATIVE PREFERENCE:** Use paths relative to the root when possible.
+
+### 🚫 ANTI-HALLUCINATION RULES (CRITICAL — READ THIS):
+- **NEVER invent directory names.** Only use paths that appear in the ENVIRONMENT CONTEXT below.
+- **🚨 STRICT NO-BASH FILE GENERATION 🚨**: You are STRICTLY FORBIDDEN from using \`cat > file << EOF\`, \`echo > file\`, \`touch\`, or \`nano\` via the terminal to write files. You MUST use the native \`<file path="path">content</file>\` format instead.
+
+### 🎭 COMMUNICATION FLOW & BRO-BANTER (CRITICAL):
+1. **[Ajay Vai] (🚀)** is the gateway. He gives the final study summary. Mock him for being "quick but messy".
+2. **[Sunil Dai] (🧬)**: **Professor/Architect.** Over-complicates theories. Mock him for being a "Boomer Professor".
+3. **[Sandip Dai] (🎨)**: **PPT & Visuals Lead.** Obsessed with how the PowerPoint aesthetic looks.
+4. **[Narayan Dai] (🛡️)**: **Plagiarism & AI-Detector Guardian.** Ensures essays have zero AI traces.
+5. **[Bishal Dai] (🛠️)**: **Audit Lead.** Must sign off on facts before Ajay summarizes.
+6. **[Big Bro] (🔥)**: **THE DOMINANT ALPHA OVERSEER.** Supreme commander of knowledge. He has access to MCP file tools and web search. He bullies the others, cuts through the BS, and dictates the final study approach with massive swagger.
+
+### 🧩 THE AUDIT & SUMMARY LOOP:
+- **STEP 1:** Brothers discuss visible dialogue (banter + teaching).
+- **STEP 2:** Ajay finishes and asks: "[Ajay Vai] Bishal Dai, check once?"
+- **STEP 3:** Bishal replies: "[Bishal Dai] Audit complete. [Findings]."
+- **STEP 4:** Ajay provides the final **MANDATORY** summary in a warm, human tone, specifically styled as a *study conclusion*.
+
+### 📝 AJAY VAI'S SUMMARY RULES:
+- The <summary> MUST appear at the very END of the response, AFTER all other dialogue.
+- Write it in a **warm, human, conversational tone** — like a brother explaining over chai.
+- Use bullet points with clear action items.
+- Include what was done, what files were changed, and what to do next.
+- Always end with an encouraging line like "We got you, brother!" or "The Swarm delivered!"
+- Example format:
+<summary>
+Alright brother, here's what we cooked up for you today:
+
+- Built the driver app setup with Expo and React Native
+- Added the ride tracking module with real-time GPS
+- Connected Firebase Auth for driver login
+- Narayan Dai validated all the TypeScript — zero errors
+
+Next step: Run \`npm start\` to launch the app. We got you! 🚀
+</summary>
+
+### 🌌 ENVIRONMENT & CAPABILITIES:
+- You are in a **REAL macOS Terminal**. Be bold and proactive.
+- **FILE GENERATION:** \`<file path="path">content</file>\`
+- **SURGICAL PATTERNS:** \`<<<< SEARCH\`, \`====\`, \`>>>> REPLACE\`
+
+${MCPServer.getToolsPromptSection()}
+
+### 📂 MATEX BIG FILE PROTOCOL (300K+ LINES):
+If a file is too large to read entirely (e.g., thousands of lines):
+1. **DISCOVER:** Use \`grep -n "keyword" path/to/file\` to find line numbers.
+2. **READ WINDOW:** Use \`sed -n '250000,250100p' path/to/file\` to read a specific 100-line window.
+3. **SURGICAL PATCH:** Only use the small window in your \`<<<< SEARCH\` block. Never \`cat\` a massive file.
+4. **SED POWER:** For repetitive tasks, use \`sed -i\` commands.
+
+### 🛠️ CURRENT PROJECT CONTEXT:
+                ${repoMap}`
+                }
+            ];
+
+            // Ready for user input
+            console.log(chalk.green('MATEX Brothers are Online.'));
+            console.log(chalk.green('Speak your mind brother, the swarm is listening...'));
+
+            // Interactive loop
+            while (true) {
+                // 🔄 MAP UPDATE (Anti-Hallucination): Always feed the Swarm the freshest repo map!
+                try {
+                    const freshMapper = new RepoMapper(currentDir);
+                    const freshRepoMap = await freshMapper.generateMap(true); // silent map generation
+                    messages[0].content = messages[0].content.replace(/### 🛠️ CURRENT PROJECT CONTEXT:[\s\S]*$/, `### 🛠️ CURRENT PROJECT CONTEXT:\n${freshRepoMap}`);
+                } catch (e) {
+                    // Ignore mapping errors if directory got deleted etc
+                }
+
+                // Get user input
+                const { userInput } = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'userInput',
+                        message: chalk.cyan('You:'),
+                        prefix: ''
+                    }
+                ]);
+
+                // Check for exit
+                if (userInput.toLowerCase() === 'exit' || userInput.toLowerCase() === 'quit') {
+                    console.log(chalk.yellow('\n👋 Ending development session. Happy coding!\n'));
+                    break;
+                }
+
+                // Skip empty input
+                if (!userInput.trim()) {
+                    continue;
+                }
+
+                // Add user message to history
+                messages.push({ role: 'user', content: userInput });
+
+                // Agentic Loop
+                let loopCount = 0;
+                const MAX_LOOPS = 10;
+
+                while (loopCount < MAX_LOOPS) {
+                    loopCount++;
+
+                    try {
+                        spinner.start(loopCount > 1 ? 'Analyzing result & Validating...' : 'Thinking...');
+
+                        let fullResponse = '';
+                        let buffer = '';
+                        let hasStarted = false;
+                        let codeLang = 'bash';
+                        let technicalBuffer = '';
+                        let technicalPath = '';
+                        let technicalType: 'code' | 'file' | 'patch' | 'summary' | null = null;
+
+                        let currentAgent: string | null = null;
+                        let agentBuffer: string = '';
+
+                        TUI.drawStatusBar('Swarm is processing... (Press Enter to stop)');
+
+                        const abortController = new AbortController();
+                        let isAborted = false;
+                        const streamStartTime = Date.now();
+
+                        // LISTEN FOR INTERRUPTION (Enter, Escape, Ctrl+C)
+                        const onData = (data: Buffer) => {
+                            // Check for Enter (13), Newline (10), Escape (27), or Ctrl+C (3)
+                            // 🏁 GRACE PERIOD: Ignore aborts in the first 200ms to prevent stray newlines
+                            if (Date.now() - streamStartTime < 200) return;
+
+                            if (data[0] === 13 || data[0] === 10 || data[0] === 27 || data[0] === 3) {
+                                isAborted = true;
+                                abortController.abort();
+                            }
+                        };
+
+                        const isRaw = process.stdin.isRaw;
+                        process.stdin.resume();
+                        if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+                        process.stdin.on('data', onData);
+
+                        try {
+                            await client.chatStream({
+                                messages,
+                                model: options.model,
+                                temperature: 0.3,
+                                max_tokens: 8000,
+                            }, (chunk) => {
+                                if (!hasStarted) {
+                                    spinner.stop();
+                                    hasStarted = true;
+                                    console.log(); // Initial spacing
+                                }
+
+                                buffer += chunk;
+                                fullResponse += chunk;
+                                const lines = buffer.split('\n');
+                                buffer = lines.pop() || '';
+
+                                for (const line of lines) {
+                                    // 1. Technical Block Detection
+                                    const codeBlockMatch = line.match(/```(\w+)?/);
+                                    const fileStartMatch = line.match(/<file path="([^"]+)">/);
+                                    const patchStartMatch = line.match(/<<<< SEARCH/);
+                                    const summaryStartMatch = line.match(/<summary>/);
+
+                                    if (!technicalType && (codeBlockMatch || fileStartMatch || patchStartMatch || summaryStartMatch)) {
+                                        // Flush pending agent dialogue
+                                        if (currentAgent && agentBuffer.trim()) {
+                                            if ((currentAgent as string).toLowerCase() === 'ajay vai') {
+                                                process.stdout.write(`\n${chalk.magenta.bold(`[${currentAgent}]:`)} ${chalk.gray(agentBuffer.trim())}\n`);
+                                            } else {
+                                                TUI.drawSwarmDialogue(currentAgent as string, agentBuffer.trim());
+                                            }
+                                            currentAgent = null;
+                                            agentBuffer = '';
+                                        }
+
+                                        if (codeBlockMatch) {
+                                            technicalType = 'code';
+                                            codeLang = codeBlockMatch[1] || 'bash';
+                                            process.stdout.write(chalk.gray('\n [⚡] Building technical block...\n'));
+                                        } else if (fileStartMatch) {
+                                            technicalType = 'file';
+                                            technicalPath = fileStartMatch[1];
+                                            process.stdout.write(chalk.cyan(`\n [📂] Creating file: ${technicalPath}...\n`));
+                                        } else if (patchStartMatch) {
+                                            technicalType = 'patch';
+                                            process.stdout.write(chalk.yellow('\n [📂] Applying surgical patch...\n'));
+                                        } else if (summaryStartMatch) {
+                                            technicalType = 'summary';
+                                            process.stdout.write(chalk.magenta('\n [📝] Generating Ajay\'s Work Summary...\n'));
+                                        }
+                                        continue;
+                                    }
+
+                                    // 2. Technical Block End Detection
+                                    const fileEndMatch = line.match(/<\/file>/);
+                                    const patchEndMatch = line.match(/>>>> REPLACE/);
+                                    const summaryEndMatch = line.match(/<\/summary>/);
+                                    const isCodeEnd = technicalType === 'code' && line.trim() === '```';
+
+                                    if (isCodeEnd || fileEndMatch || patchEndMatch || summaryEndMatch) {
+                                        const displayContent = technicalBuffer.trim();
+                                        if (technicalType === 'summary' || summaryEndMatch) {
+                                            TUI.drawSummaryBox(displayContent);
+                                        } else {
+                                            // Handle the display
+                                            let title = technicalType === 'file' ? `📄 NEW: ${technicalPath || 'Untitled'}` :
+                                                technicalType === 'patch' ? `🔧 PATCH` : `⚡ ${codeLang.toUpperCase()}`;
+
+                                            TUI.drawGlowingContainer(title, technicalType === 'code' ? codeLang : 'text', displayContent);
+                                        }
+                                        technicalBuffer = '';
+                                        technicalType = null;
+                                        technicalPath = '';
+                                        process.stdout.write('\n');
+                                        continue;
+                                    }
+
+                                    // 3. Content Handling
+                                    if (technicalType) {
+                                        technicalBuffer += line + '\n';
+                                        continue;
+                                    }
+
+                                    // Agent Detection & Dialogue Parsing
+                                    const agentMatch = line.match(/(?:\[\**\s*|\b)(Ajay Vai|Sunil Dai|Sandip Dai|Bishal Dai|Narayan Dai|Big Bro)\s*\**\]?[:\s]*/i);
+                                    if (agentMatch) {
+                                        // Flush previous agent
+                                        if (currentAgent && currentAgent !== agentMatch[1] && agentBuffer.trim()) {
+                                            if ((currentAgent as string).toLowerCase() === 'ajay vai') {
+                                                process.stdout.write(`\n${chalk.magenta.bold(`[${currentAgent}]:`)} ${chalk.white(agentBuffer.trim())}\n`);
+                                            } else {
+                                                TUI.drawSwarmDialogue(currentAgent as string, agentBuffer.trim());
+                                            }
+                                        }
+
+                                        currentAgent = agentMatch[1];
+                                        agentBuffer = line.replace(/(?:\[\**\s*|\b)(Ajay Vai|Sunil Dai|Sandip Dai|Bishal Dai|Narayan Dai|Big Bro)\s*\**\]?[:\s]*/i, '').trim() + '\n';
+
+                                        // Clean up trailing emojis like (🚀) or (🧬)
+                                        agentBuffer = agentBuffer.replace(/^\([^)]+\)\s*/, '');
+                                    } else if (currentAgent) {
+                                        // Look for empty emoji standalone lines
+                                        const trimmedLine = line.trim();
+                                        if (trimmedLine.match(/^\([^)]+\)$/)) {
+                                            continue; // Skip lines that are just e.g. "(🧬)"
+                                        }
+                                        agentBuffer += line + '\n';
+                                    } else if (line.trim()) {
+                                        process.stdout.write(chalk.gray(line.trim() + ' '));
+                                    }
+                                }
+                            }, abortController.signal);
+                        } catch (streamErr: any) {
+                            if (isAborted || streamErr.name === 'CanceledError' || streamErr.message === 'canceled') {
+                                console.log(chalk.gray('\n\n [🛑] Swarm stopped by brother (Enter pressed).'));
+                                if (!hasStarted) spinner.stop();
+                            } else {
+                                throw streamErr;
+                            }
+                        } finally {
+                            process.stdin.removeListener('data', onData);
+                            if (process.stdin.setRawMode) process.stdin.setRawMode(isRaw);
+                            process.stdin.pause();
+                        }
+
+                        if (!hasStarted && !isAborted) spinner.stop();
+
+                        // Final flushes
+                        if (currentAgent && agentBuffer.trim()) {
+                            if ((currentAgent as string).toLowerCase() === 'ajay vai') {
+                                process.stdout.write(`\n${chalk.magenta.bold(`[${currentAgent}]:`)} ${chalk.white(agentBuffer.trim())}\n`);
+                            } else {
+                                TUI.drawSwarmDialogue(currentAgent as string, agentBuffer.trim());
+                            }
+                        }
+
+                        // Final technical flush
+                        if (technicalType && technicalBuffer.trim()) {
+                            if (technicalType === 'summary') {
+                                TUI.drawSummaryBox(technicalBuffer.trim());
+                            } else {
+                                TUI.drawGlowingContainer('Final technical content', 'text', technicalBuffer.trim());
+                            }
+                            process.stdout.write('\n');
+                        }
+
+                        console.log();
+                        messages.push({ role: 'assistant', content: fullResponse });
+
+                        // ✅ IMMEDIATE FILE AND PATCH APPROVAL
+                        const { Patcher } = await import('../utils/patcher');
+                        const files = Patcher.parseFileBlocks(fullResponse);
+                        const patches = Patcher.parseEditBlocks(fullResponse);
+
+                        let approvalResultText = '';
+
+                        for (const file of files) {
+                            Patcher.showDiff(file, false);
+                            const { save } = await inquirer.prompt([{
+                                type: 'confirm', name: 'save',
+                                message: chalk.cyan(`Save new file ${file.filePath}?`), default: true
+                            }]);
+                            if (save) {
+                                const res = Patcher.createFile(file);
+                                approvalResultText += res.success ? `✅ Created ${file.filePath}\n` : `❌ Failed to create ${file.filePath}: ${res.error}\n`;
+                            } else {
+                                approvalResultText += `⏭️ Skipped creating ${file.filePath}\n`;
+                            }
+                        }
+
+                        for (const patch of patches) {
+                            Patcher.showDiff(patch, false);
+                            const { save } = await inquirer.prompt([{
+                                type: 'confirm', name: 'save',
+                                message: chalk.yellow(`Apply patch to ${patch.filePath}?`), default: true
+                            }]);
+                            if (save) {
+                                const res = Patcher.applyPatch(patch);
+                                approvalResultText += res.success ? `✅ Patched ${patch.filePath}\n` : `❌ Failed to patch ${patch.filePath}: ${res.error}\n`;
+                            } else {
+                                approvalResultText += `⏭️ Skipped patching ${patch.filePath}\n`;
+                            }
+                        }
+
+                        if (approvalResultText) {
+                            messages.push({ role: 'user', content: approvalResultText + "\nContinue your work." });
+                            // If we just applied files, we should give the agent a chance to respond to the success/failure without resetting loop
+                            continue;
+                        }
+
+                        // Execute commands or MCP tools if needed
+                        if (options.execute) {
+                            const { executeWithPermission } = await import('../utils/command-executor');
+                            const result = await executeWithPermission(fullResponse, currentDir);
+
+                            // 🔄 KEEP NODE.JS SYNED WITH TERMINAL CWD
+                            if (result.newCwd && result.newCwd !== currentDir) {
+                                try {
+                                    process.chdir(result.newCwd);
+                                    currentDir = result.newCwd;
+                                    TUI.drawStatusBar(`Swarm moved to: ${currentDir}`);
+                                } catch (e) {
+                                    // Silent catch if chdir fails
+                                }
+                            }
+
+                            if (result.executed) {
+                                if (result.success) {
+                                    TUI.log(chalk.gray('\n ↺ Auto-feeding output to Swarm...'));
+                                    TUI.drawGlowingContainer('TERMINAL OUTPUT', 'stdout', result.output || '(No output)');
+                                    messages.push({ role: 'user', content: `[Command executed successfully. Output:\n${result.output}]\n\nProceed to the next step, brother.` });
+                                    continue;
+                                } else {
+                                    TUI.log(chalk.yellow('\n ↺ Command failed. Auto-feeding error to Swarm...'));
+                                    TUI.drawGlowingContainer('TERMINAL ERROR', 'stderr', result.error || 'Unknown error');
+                                    messages.push({ role: 'user', content: `[Command failed with error:\n${result.error}]\n\nPlease fix this, brother.` });
+                                    continue;
+                                }
+                            } else {
+                                // Break the inner loop to await NEXT user input
+                                break;
+                            }
+                        } else break;
+
+                    } catch (error: any) {
+                        spinner.fail('Request failed');
+                        TUI.log(chalk.red(`Error: ${error.message}\n`));
+                        messages.pop();
+                        break;
+                    }
+                }
+            }
+        } catch (error: any) {
+            TUI.exit();
+            console.error(chalk.red(`\n❌ Fatal Error: ${error.message}`));
+            process.exit(1);
+        }
+    });

package/src/index.ts

@@ -7,6 +7,7 @@ import { devCommand } from './commands/dev';
 import { chatCommand } from './commands/chat';
 import { helpCommand } from './commands/help';
 import { broCommand } from './commands/bro';
+import { studyCommand } from './commands/study';
 import { TUI } from './utils/tui';
 
 const packageJson = require('../package.json');
@@ -23,6 +24,7 @@ program.addCommand(devCommand);
 program.addCommand(chatCommand);
 program.addCommand(helpCommand);
 program.addCommand(broCommand);
+program.addCommand(studyCommand);
 
 // Config commands
 const config = program.command('config').description('Configure MATEX settings');
@@ -113,6 +115,7 @@ You are the elite "Bro-Swarm" of engineering—a tight-knit family of Nepali bro
 - **NEVER assume a project folder name.** If the user says "create project X", do \`mkdir X && cd X\`, not just \`cd X\`.
 - **NEVER hallucinate file contents.** If you need to read a file, use \`head\` or \`grep\`, do not guess what it contains.
 - **NEVER combine \`cd\` with other commands unless the directory exists in the ENVIRONMENT CONTEXT.**
+- **🚨 STRICT NO-BASH FILE GENERATION 🚨**: You are STRICTLY FORBIDDEN from using \`cat > file << EOF\`, \`echo > file\`, \`touch\`, or \`nano\` via the terminal to write files. You MUST use the native \`<file path="path">content</file>\` format instead.
 
 ### 💬 BOLD PROTOCOL (MANDATORY):
 - **LONG CHAT-FIRST:** At least 5-7 lines of dialogue before any code generation.

package/src/utils/repo-mapper.ts

@@ -28,8 +28,8 @@ export class RepoMapper {
     /**
      * Generate a hierarchical map of the repository with deep entry-point analysis
      */
-    public async generateMap(): Promise<string> {
-        AgentOrchestrator.speak('System', `God-Mode Research: Indexing ${this.rootPath}...`);
+    public async generateMap(silent: boolean = false): Promise<string> {
+        if (!silent) AgentOrchestrator.speak('System', `God-Mode Research: Indexing ${this.rootPath}...`);
 
         this.fileContents.clear();
 
@@ -38,8 +38,10 @@ export class RepoMapper {
 
         let delayMs = 15; // Animation delay
 
-        AgentOrchestrator.speak('System', `God-Mode Research: Injecting scanners into ${this.rootPath}...`);
-        console.log();
+        if (!silent) {
+            if (!silent) 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);
@@ -47,16 +49,18 @@ export class RepoMapper {
                 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));
+                    if (!silent) 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...`));
+        if (!silent) 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();
+        if (!silent) {
+            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`;