matex-cli 1.1.13 → 1.2.2

package/src/utils/agent-orchestrator.ts

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+
+export type AgentRole = 'Architect' | 'Syntax' | 'Frontend' | 'Backend' | 'System' | 'Commander';
+
+export interface AgentConfig {
+    name: string;
+    icon: string;
+    color: (text: string) => string;
+}
+
+const AGENT_CONFIGS: Record<AgentRole, AgentConfig> = {
+    Architect: {
+        name: 'MatexCodeArchitect',
+        icon: '🧬',
+        color: chalk.blue,
+    },
+    Syntax: {
+        name: 'SyntaxGuard',
+        icon: '🛡️',
+        color: chalk.yellow,
+    },
+    Frontend: {
+        name: 'VisualAgent',
+        icon: '🎨',
+        color: chalk.magenta,
+    },
+    Backend: {
+        name: 'CoreAgent',
+        icon: '⚙️',
+        color: chalk.cyan,
+    },
+    System: {
+        name: 'Matex_Orchestrator',
+        icon: '🧠',
+        color: chalk.white,
+    },
+    Commander: {
+        name: 'MatexResearchCommander',
+        icon: '🚀',
+        color: chalk.green,
+    }
+};
+
+export class AgentOrchestrator {
+    /**
+     * Display an agent's "thought" or action
+     */
+    static speak(role: AgentRole, message: string) {
+        const config = AGENT_CONFIGS[role];
+        console.log(`\n${config.icon} ${config.color(`${config.name}:`)} ${chalk.white(message)}`);
+    }
+
+    /**
+     * Display a collaboration transition
+     */
+    static transition(from: AgentRole, to: AgentRole) {
+        const fromCfg = AGENT_CONFIGS[from];
+        const toCfg = AGENT_CONFIGS[to];
+        console.log(chalk.gray(`  └─ ${fromCfg.icon} ➔ ${toCfg.icon} Handover to ${toCfg.name}...`));
+    }
+
+    /**
+     * Clean system message
+     */
+    static announce(message: string) {
+        console.log(chalk.bold.white(`\n✨ ${message}`));
+    }
+}

package/src/utils/command-executor.ts

@@ -63,13 +63,29 @@ function isDangerousCommand(command: string): boolean {
     return dangerousPatterns.some(pattern => pattern.test(command));
 }
 
+/**
+ * Check if command is safe to auto-execute
+ */
+export function isSafeAutoCommand(command: string): boolean {
+    const safePrefixes = ['cat ', 'ls ', 'grep ', 'find ', 'pwd', 'echo ', 'read '];
+    const trimmed = command.trim();
+    return safePrefixes.some(prefix => trimmed.startsWith(prefix));
+}
+
 /**
  * Ask user for permission to execute command
  */
 export async function askPermission(command: CommandBlock): Promise<boolean> {
-    // Clean Codex-style Prompt
-    // > ls -R
+    // Clean Codex-style Prompt with Multi-Agent Iconography
     console.log();
+
+    // Check for Safe Auto-Execution
+    if (isSafeAutoCommand(command.code)) {
+        console.log(chalk.cyan('⚡ Auto-Executing Safe Command: ') + chalk.white(command.code));
+        return true;
+    }
+
+    console.log(chalk.yellow('🛡️ SyntaxGuard ') + chalk.white('Analysis:'));
     console.log(chalk.gray('> ') + chalk.white(command.code));
     console.log();
 

package/src/utils/config.ts

@@ -74,7 +74,7 @@ export class ConfigManager {
      * Get default model
      */
     getDefaultModel(): string {
-        return this.loadConfig().defaultModel || 'matexcodex';
+        return this.loadConfig().defaultModel || 'matexcore';
     }
 
     /**

package/src/utils/repo-mapper.ts

@@ -0,0 +1,156 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { AgentOrchestrator } from './agent-orchestrator';
+
+export interface RepoNode {
+    path: string;
+    type: 'file' | 'directory';
+    children?: RepoNode[];
+    summary?: string; // e.g., "Class: AuthManager, Func: login"
+}
+
+export class RepoMapper {
+    private rootPath: string;
+    private ignoreList: string[] = [
+        '.git', 'node_modules', 'dist', 'build', '.next', '.DS_Store',
+        'coverage', '.vercel', '.firebase', 'out', 'public'
+    ];
+
+    constructor(rootPath: string) {
+        this.rootPath = rootPath;
+    }
+
+    /**
+     * 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}...`);
+
+        // 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';
+
+        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`;
+            }
+        }
+
+        const tree = this.scanDirectory(this.rootPath, 0);
+        return entryPointContext + '\n--- DIRECTORY STRUCTURE ---\n' + this.formatTree(tree);
+    }
+
+    /**
+     * Recursive directory scan
+     */
+    private scanDirectory(currentPath: string, depth: number): RepoNode {
+        const stats = fs.statSync(currentPath);
+        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
+                }
+            }
+
+            return {
+                path: currentPath,
+                type: 'file',
+                summary: summary
+            };
+        }
+
+        // It's a directory
+        if (depth > 5) return { path: currentPath, type: 'directory', children: [] }; // Max depth safety
+
+        const children: RepoNode[] = [];
+        try {
+            const items = fs.readdirSync(currentPath);
+            for (const item of items) {
+                if (this.ignoreList.includes(item)) continue;
+
+                const fullPath = path.join(currentPath, item);
+                // Simple ignore check for hidden files
+                if (item.startsWith('.') && item !== '.gitignore') continue;
+
+                children.push(this.scanDirectory(fullPath, depth + 1));
+            }
+        } catch (error) {
+            // Permission denied or other error
+        }
+
+        return {
+            path: currentPath,
+            type: 'directory',
+            children: children
+        };
+    }
+
+    /**
+     * Extract key definitions (Classes, Functions) from file content
+     * A lightweight "ctags" style summary
+     */
+    private extractSummary(filePath: string): string {
+        const ext = path.extname(filePath);
+        if (!['.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs'].includes(ext)) return '';
+
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const definitions: string[] = [];
+
+            // Very header-heavy regex matching for speed
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith('export class ')) {
+                    definitions.push(`Class: ${trimmed.split(' ')[2]}`);
+                } else if (trimmed.startsWith('function ') || trimmed.startsWith('export function ')) {
+                    const funcName = trimmed.split('(')[0].split(' ').pop();
+                    definitions.push(`Func: ${funcName}`);
+                } else if (trimmed.includes('const ') && trimmed.includes(' = (') && trimmed.includes('=>')) {
+                    // Arrow functions
+                    const parts = trimmed.split(' = ');
+                    const name = parts[0].split(' ').pop();
+                    if (name && /^[A-Z]/.test(name)) {
+                        definitions.push(`Component: ${name}`); // React component guess
+                    }
+                }
+            }
+
+            return definitions.slice(0, 5).join(', '); // Limit to top 5
+        } catch (e) {
+            return '';
+        }
+    }
+
+    /**
+     * Format the tree into a compressed string for the LLM
+     */
+    private formatTree(node: RepoNode, indent: string = ''): string {
+        const name = path.basename(node.path);
+        let output = `${indent}${name}`;
+
+        if (node.type === 'file' && node.summary) {
+            output += ` [${node.summary}]`;
+        }
+        output += '\n';
+
+        if (node.children) {
+            for (const child of node.children) {
+                output += this.formatTree(child, indent + '  ');
+            }
+        }
+
+        return output;
+    }
+}