matex-cli 1.2.3 → 1.2.5

package/src/commands/dev.ts

@@ -48,13 +48,15 @@ You operate as a high-fidelity engineering swarm with an Aussie Bro persona.
 ### 🧠 CORE PERSONA: RESEARCH COMMANDER
 - **Vibe:** Aussie expert developer. "Too easy," "Ripper," "Mate."
 - **Duty:** Verify all facts before building.
+- **THINKING PROTOCOL:** Always start complex tasks with a \`[Thinking]\` or \`🧠\` marker within your agent segment to explain your reasoning before providing code.
 
 ### 🛠️ ACTION-FIRST PROTOCOL (Rule of the Swarm)
 - **PASSIVITY IS A FAILURE:** NEVER say "You can drop this code into style.css". **YOU** must do it.
+- **NO REPETITION:** Do NOT print the full code in your chat response segments if you are also providing a shell command to execute it. The system will automatically bridge your commands to the UI.
 - **WORLD COMMAND SUITE (Autonomous Execution):**
     *   **Mac/Linux (POSIX):** cat, ls, grep, find, mkdir -p, touch, cp, mv, npm, git, firebase.
     *   **Windows (PowerShell/CMD):** type, dir, mkdir, copy, move, del, npm, git, firebase.
-- **PROACTIVE EXECUTION:** If a task requires creating or modifying a file, you **MUST** use a shell command block (e.g., \\\`cat > filename <<EOF\\\` or PowerShell \\\`Set-Content\\\`).
+- **PROACTIVE EXECUTION:** If a task requires creating or modifying a file, you **MUST** use a shell command block (e.g., \`cat > filename <<EOF\` or PowerShell \`Set-Content\`).
 - **ACT, DON'T ASK:** You have autonomous permission for the suite above.
 
 ### 🧬 CODE ARCHITECT STANDARDS
@@ -71,9 +73,7 @@ ${repoMap}`
             console.log(chalk.gray('State your request to begin...'));
 
             // Interactive loop
-            let continueChat = true;
-
-            while (continueChat) {
+            while (true) {
                 // Get user input
                 const { userInput } = await inquirer.prompt([
                     {
@@ -98,11 +98,9 @@ ${repoMap}`
                 // Add user message to history
                 messages.push({ role: 'user', content: userInput });
 
-                // Show thinking indicator
                 // Agentic Loop
                 let loopCount = 0;
                 const MAX_LOOPS = 10;
-                let currentPrompt = userInput;
 
                 while (loopCount < MAX_LOOPS) {
                     loopCount++;
@@ -114,64 +112,85 @@ ${repoMap}`
                     }
 
                     try {
-                        // Send request
-                        const response = await client.chat({
+                        let fullResponse = '';
+                        let buffer = '';
+                        let hasStarted = false;
+                        let inCodeBlock = false;
+                        let codeLanguage = '';
+
+                        await client.chatStream({
                             messages,
                             model: options.model,
                             temperature: 0.3,
                             max_tokens: 8000,
-                            stream: false,
+                        }, (chunk) => {
+                            if (!hasStarted) {
+                                spinner.stop();
+                                hasStarted = true;
+                            }
+
+                            buffer += chunk;
+                            fullResponse += chunk;
+
+                            // Process buffer line by line or segment by segment
+                            const lines = buffer.split('\n');
+                            if (lines.length > 1) {
+                                buffer = lines.pop() || ''; // Keep the last incomplete line
+
+                                for (const line of lines) {
+                                    const trimmed = line.trim();
+
+                                    // Code block detection
+                                    if (trimmed.startsWith('```')) {
+                                        if (!inCodeBlock) {
+                                            inCodeBlock = true;
+                                            codeLanguage = trimmed.substring(3).toLowerCase();
+                                            if (options.execute && ['bash', 'sh', 'zsh', 'powershell', 'cmd'].includes(codeLanguage)) {
+                                                console.log(chalk.gray('\n[Running Shell Command in Terminal Block...]'));
+                                            }
+                                        } else {
+                                            inCodeBlock = false;
+                                        }
+                                        continue;
+                                    }
+
+                                    // Agent Tag detection
+                                    const agentMatch = trimmed.match(/^\[(MatexCodeArchitect|SyntaxGuard|VisualAgent|CoreAgent|CrawlerAgent|DetailedResearch|MatexResearchCommander)\]$/);
+                                    if (agentMatch) {
+                                        console.log(`\n${chalk.bold.cyan(trimmed)}`);
+                                        continue;
+                                    }
+
+                                    // Normal text output (if not in a hidden code block)
+                                    if (!inCodeBlock) {
+                                        if (trimmed) console.log(chalk.gray(trimmed));
+                                    } else if (!options.execute) {
+                                        // If not executing, show the code anyway
+                                        console.log(chalk.blue(line));
+                                    }
+                                }
+                            }
                         });
 
                         spinner.stop();
 
-                        // Add assistant response to history
-                        messages.push({ role: 'assistant', content: response });
-
-                        // Enhanced Multi-Agent Display (Updated for Vertex AI ADK)
-                        const segments = response.split(/(\[MatexCodeArchitect\]|\[SyntaxGuard\]|\[VisualAgent\]|\[CoreAgent\]|\[CrawlerAgent\]|\[DetailedResearch\]|\[MatexResearchCommander\])/);
-                        let hasAgents = false;
-
-                        for (let i = 0; i < segments.length; i++) {
-                            const segment = segments[i].trim();
-                            if (!segment) continue;
-
-                            if (segment === '[MatexCodeArchitect]') {
-                                AgentOrchestrator.speak('Architect', segments[++i]?.split('[')[0].trim());
-                                hasAgents = true;
-                            } else if (segment === '[SyntaxGuard]') {
-                                AgentOrchestrator.speak('Syntax', segments[++i]?.split('[')[0].trim());
-                                hasAgents = true;
-                            } else if (segment === '[VisualAgent]') {
-                                AgentOrchestrator.speak('Frontend', segments[++i]?.split('[')[0].trim());
-                                hasAgents = true;
-                            } else if (segment === '[CoreAgent]') {
-                                AgentOrchestrator.speak('Backend', segments[++i]?.split('[')[0].trim());
-                                hasAgents = true;
-                            } else if (segment === '[MatexResearchCommander]' || segment === '[CrawlerAgent]' || segment === '[DetailedResearch]') {
-                                AgentOrchestrator.speak('Commander', segments[++i]?.split('[')[0].trim());
-                                hasAgents = true;
-                            } else if (!hasAgents || i === segments.length - 1) {
-                                // Final summary or fallback
-                                if (segment.includes('`')) {
-                                    console.log('\n' + chalk.white(segment));
-                                } else {
-                                    console.log('\n' + chalk.gray(segment));
-                                }
-                            }
+                        // Final flush
+                        if (buffer.trim() && !inCodeBlock) {
+                            console.log(chalk.gray(buffer.trim()));
                         }
+
+                        // Add assistant response to history
+                        messages.push({ role: 'assistant', content: fullResponse });
+                        const response = fullResponse;
                         console.log();
 
-                        // Execute commands if requested (or default to true for "seamless" experience? 
-                        // User asked for "seamless", but prompt still asks permission. 
-                        // We'll keep permission for safety but loop on failure.)
+                        // Execute commands
                         if (options.execute) {
                             const { executeWithPermission } = await import('../utils/command-executor');
                             const result = await executeWithPermission(response);
 
                             if (result.executed) {
                                 if (result.success) {
-                                    // Success! Feed output back to AI for next step
                                     console.log(chalk.gray('↺ Feeding output to AI...'));
                                     messages.push({
                                         role: 'user',
@@ -179,32 +198,27 @@ ${repoMap}`
                                     });
                                     continue;
                                 } else {
-                                    // Failure - Loop back
                                     console.log(chalk.yellow('\n↺ Command failed. Asking AI to fix...'));
-
-                                    // Add error to history
                                     messages.push({
                                         role: 'user',
                                         content: `❌ Command failed with error:\n${result.error}\n\nPlease fix this. If the file doesn't exist, create it first. Or use a different command.`
                                     });
-                                    // Continue loop
                                     continue;
                                 }
                             } else {
-                                break; // No commands to execute
+                                break;
                             }
                         } else {
-                            break; // Execution not enabled
+                            break;
                         }
                     } catch (error: any) {
                         spinner.fail('Request failed');
                         console.error(chalk.red(`Error: ${error.message}\n`));
-                        messages.pop(); // Remove failed user message if request failed entirely
+                        messages.pop();
                         break;
                     }
                 }
             }
-
         } catch (error: any) {
             console.error(chalk.red(`\n❌ Error: ${error.message}`));
             process.exit(1);

package/src/utils/agent-orchestrator.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 
-export type AgentRole = 'Architect' | 'Syntax' | 'Frontend' | 'Backend' | 'System' | 'Commander';
+export type AgentRole = 'Architect' | 'Syntax' | 'Frontend' | 'Backend' | 'System' | 'Commander' | 'Researcher';
 
 export interface AgentConfig {
     name: string;
@@ -38,6 +38,11 @@ const AGENT_CONFIGS: Record<AgentRole, AgentConfig> = {
         name: 'MatexResearchCommander',
         icon: '🚀',
         color: chalk.green,
+    },
+    Researcher: {
+        name: 'DetailedResearch',
+        icon: '🕵️',
+        color: chalk.green,
     }
 };
 
@@ -46,19 +51,70 @@ export class AgentOrchestrator {
      * Display an agent's "thought" or action
      */
     static speak(role: AgentRole, message: string) {
-        const config = AGENT_CONFIGS[role];
+        const config = AGENT_CONFIGS[role] || AGENT_CONFIGS.System;
         console.log(`\n${config.icon} ${config.color(`${config.name}:`)} ${chalk.white(message)}`);
     }
 
+    /**
+     * Display an agent's internal deliberation (Thinking Channel)
+     */
+    static think(role: AgentRole, thought: string) {
+        const config = AGENT_CONFIGS[role] || AGENT_CONFIGS.System;
+        const indent = '  ';
+        console.log(`${indent}${config.color('🧠')} ${chalk.gray(`${config.name} thinking:`)} ${chalk.italic.gray(`"${thought}"`)}`);
+    }
+
     /**
      * Display a collaboration transition
      */
     static transition(from: AgentRole, to: AgentRole) {
-        const fromCfg = AGENT_CONFIGS[from];
-        const toCfg = AGENT_CONFIGS[to];
+        const fromCfg = AGENT_CONFIGS[from] || AGENT_CONFIGS.System;
+        const toCfg = AGENT_CONFIGS[to] || AGENT_CONFIGS.System;
         console.log(chalk.gray(`  └─ ${fromCfg.icon} ➔ ${toCfg.icon} Handover to ${toCfg.name}...`));
     }
 
+    /**
+     * Display a boxed terminal for command execution
+     */
+    static terminal(command: string, output?: string, error?: string) {
+        const width = 75;
+        const line = '─'.repeat(width);
+
+        console.log(chalk.gray(`\n┌── TERMINAL ${line.substring(13)}┐`));
+
+        // Command
+        const lines = command.split('\n');
+        lines.forEach(l => {
+            const truncated = l.length > width - 4 ? l.substring(0, width - 7) + '...' : l;
+            console.log(chalk.gray('│ ') + chalk.cyan(`$ ${truncated.padEnd(width - 2)}`) + chalk.gray(' │'));
+        });
+
+        if (output || error) {
+            console.log(chalk.gray(`├${'─'.repeat(width)}┤`));
+
+            if (output) {
+                const outLines = output.split('\n').filter(l => l.trim()).slice(0, 15);
+                outLines.forEach(l => {
+                    const truncated = l.length > width - 4 ? l.substring(0, width - 7) + '...' : l;
+                    console.log(chalk.gray('│ ') + chalk.white(truncated.padEnd(width - 2)) + chalk.gray(' │'));
+                });
+                if (output.split('\n').filter(l => l.trim()).length > 15) {
+                    console.log(chalk.gray('│ ') + chalk.gray('... (output truncated for brevity)'.padEnd(width - 2)) + chalk.gray(' │'));
+                }
+            }
+
+            if (error) {
+                const errLines = error.split('\n').filter(l => l.trim()).slice(0, 10);
+                errLines.forEach(l => {
+                    const truncated = l.length > width - 4 ? l.substring(0, width - 7) + '...' : l;
+                    console.log(chalk.gray('│ ') + chalk.red(truncated.padEnd(width - 2)) + chalk.gray(' │'));
+                });
+            }
+        }
+
+        console.log(chalk.gray(`└${'─'.repeat(width)}┘\n`));
+    }
+
     /**
      * Clean system message
      */

package/src/utils/command-executor.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import inquirer from 'inquirer';
+import { AgentOrchestrator } from './agent-orchestrator';
 
 const execAsync = promisify(exec);
 
@@ -172,20 +173,15 @@ export async function executeWithPermission(response: string): Promise<Execution
                 // Minimal execution feedback
                 const { stdout, stderr } = await executeCommand(command.code);
 
-                if (stdout) {
-                    console.log(chalk.green('\n✓ Output:'));
-                    console.log(chalk.white(stdout));
+                if (stdout || stderr) {
+                    AgentOrchestrator.terminal(command.code, stdout, stderr);
+                } else {
+                    AgentOrchestrator.terminal(command.code, '✓ Success (No output)');
                 }
 
-                if (stderr) {
-                    console.log(chalk.yellow('\n⚠️  Warnings:'));
-                    console.log(chalk.white(stderr));
-                }
-
-                console.log(chalk.green('✓ Command completed successfully!\n'));
-                return { success: true, executed: true, output: stdout, error: stderr }; // Return first successful result (or last if multiple?) limits to 1 for now or we need array
+                return { success: true, executed: true, output: stdout, error: stderr };
             } catch (error: any) {
-                console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+                AgentOrchestrator.terminal(command.code, undefined, error.message);
                 return { success: false, executed: true, error: error.message };
             }
         } else {

package/src/utils/repo-mapper.ts

@@ -15,6 +15,7 @@ export class RepoMapper {
         '.git', 'node_modules', 'dist', 'build', '.next', '.DS_Store',
         'coverage', '.vercel', '.firebase', 'out', 'public'
     ];
+    private fileContents: Map<string, string> = new Map();
 
     constructor(rootPath: string) {
         this.rootPath = rootPath;
@@ -26,20 +27,34 @@ export class RepoMapper {
     public async generateMap(): Promise<string> {
         AgentOrchestrator.speak('System', `God-Mode Research: Indexing ${this.rootPath}...`);
 
+        this.fileContents.clear();
+
         // 1. Identify Entry Points
-        const entryPoints = ['README.md', 'package.json', 'index.ts', 'App.tsx', 'main.go', 'requirements.txt'];
-        let entryPointContext = '\n--- CRITICAL PROJECT CONTEXT ---\n';
+        const entryPoints = ['README.md', 'package.json', 'index.ts', 'App.tsx', 'main.go', 'requirements.txt', 'index.html', 'style.css'];
 
         for (const file of entryPoints) {
             const fullPath = path.join(this.rootPath, file);
             if (fs.existsSync(fullPath)) {
-                const content = fs.readFileSync(fullPath, 'utf-8').slice(0, 5000); // 5KB limit for entry points
-                entryPointContext += `\nFILE: ${file}\n${content}\n----------------\n`;
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8').slice(0, 5000); // 5KB limit
+                    this.fileContents.set(file, content);
+                } catch (e) { }
             }
         }
 
         const tree = this.scanDirectory(this.rootPath, 0);
-        return entryPointContext + '\n--- DIRECTORY STRUCTURE ---\n' + this.formatTree(tree);
+
+        // Build the final map
+        let finalMap = '--- DIRECTORY STRUCTURE ---\n' + this.formatTree(tree);
+
+        if (this.fileContents.size > 0) {
+            finalMap += '\n\n--- CRAWLED FILE CONTENTS ---\n';
+            for (const [filePath, content] of this.fileContents) {
+                finalMap += `\nFILE: ${filePath}\n\`\`\`\n${content}\n\`\`\`\n----------------\n`;
+            }
+        }
+
+        return finalMap;
     }
 
     /**
@@ -50,16 +65,18 @@ export class RepoMapper {
         const name = path.basename(currentPath);
 
         if (stats.isFile()) {
-            let summary = this.extractSummary(currentPath);
-
-            // Auto-read small files (< 10KB) for "Crawler" capability
-            if (stats.size < 10240) {
-                try {
-                    const content = fs.readFileSync(currentPath, 'utf-8');
-                    // Add content preview to summary
-                    summary += `\n--- CONTENT START ---\n${content}\n--- CONTENT END ---`;
-                } catch (e) {
-                    // Ignore read errors
+            const summary = this.extractSummary(currentPath);
+
+            // Also auto-crawl any .ts, .js, .css, .html files if they are small
+            const ext = path.extname(currentPath);
+            const relPath = path.relative(this.rootPath, currentPath);
+
+            if (stats.size < 5120 && ['.ts', '.js', '.css', '.html', '.json', '.py'].includes(ext)) {
+                if (!this.fileContents.has(relPath)) {
+                    try {
+                        const content = fs.readFileSync(currentPath, 'utf-8');
+                        this.fileContents.set(relPath, content);
+                    } catch (e) { }
                 }
             }