@brutalist/mcp 0.1.1 → 0.4.3

package/dist/brutalist-server.js

@@ -1,28 +1,26 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { OpenRouterClient } from './openrouter.js';
+import { CLIAgentOrchestrator } from './cli-agents.js';
 import { logger } from './logger.js';
-import { DEFAULT_MAX_MODELS_PER_REQUEST } from './constants.js';
+// Package version - keep in sync with package.json
+const PACKAGE_VERSION = "0.4.1";
 export class BrutalistServer {
     server;
     config;
-    openrouter;
+    cliOrchestrator;
     constructor(config = {}) {
         this.config = {
-            maxModelsPerRequest: DEFAULT_MAX_MODELS_PER_REQUEST,
+            workingDirectory: process.cwd(),
+            defaultTimeout: 1500000, // 25 minutes for thorough CLI analysis
+            enableSandbox: true,
             ...config
         };
-        const apiKey = process.env.OPENROUTER_API_KEY || config.openRouterApiKey;
-        if (!apiKey) {
-            logger.error("OPENROUTER_API_KEY environment variable is required");
-            throw new Error("OPENROUTER_API_KEY environment variable is required");
-        }
-        logger.debug("Initializing OpenRouter client");
-        this.openrouter = new OpenRouterClient(apiKey);
+        logger.debug("Initializing CLI Agent Orchestrator");
+        this.cliOrchestrator = new CLIAgentOrchestrator();
         this.server = new McpServer({
             name: "brutalist-mcp",
-            version: "0.1.0",
+            version: PACKAGE_VERSION,
             capabilities: {
                 tools: {}
             }
@@ -30,51 +28,103 @@ export class BrutalistServer {
         this.registerTools();
     }
     async start() {
-        logger.info("Starting Brutalist MCP Server");
-        // Initialize OpenRouter client with available models
-        await this.openrouter.initialize();
+        logger.info("Starting Brutalist MCP Server with CLI Agents");
+        // Skip CLI detection at startup - will be done lazily on first request
+        logger.info("CLI context will be detected on first request");
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         logger.info("Brutalist MCP Server started successfully");
     }
     registerTools() {
-        // ROAST_CODE: Multi-model code destruction
-        this.server.tool("roast_code", "Code fails in predictable ways. Write a system prompt where you are a battle-scarred principal engineer who has debugged production disasters for 15 years. Find security holes, performance bottlenecks, and maintainability nightmares—then explain exactly how to fix each one. Be brutal about what's broken but specific about what would actually work.", {
-            code: z.string().describe("The code to analyze and destroy"),
-            fileType: z.string().optional().describe("File type/language (js, py, ts, etc.)"),
-            context: z.string().optional().describe("Additional context about the code's purpose"),
-            maxCritics: z.number().optional().describe("Maximum number of AI critics to deploy (default: 3)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_CODEBASE: Systematic destruction of entire codebase
+        this.server.tool("roast_codebase", "Deploy brutal AI critics to systematically destroy your entire codebase. These AI agents will navigate your directories, read your actual files, and find every architectural disaster, security vulnerability, and maintainability nightmare lurking in your project. They treat this like code that will kill people if it fails.", {
+            targetPath: z.string().describe("Path to analyze (file or directory)"),
+            context: z.string().optional().describe("Additional context about the codebase purpose"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from"),
+            enableSandbox: z.boolean().optional().describe("Enable sandbox mode for safe analysis (default: true)"),
+            preferredCLI: z.enum(["claude", "codex", "gemini"]).optional().describe("Preferred CLI agent to use (default: use all available CLIs)"),
+            verbose: z.boolean().optional().describe("Include detailed execution information in output (default: false)"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent (defaults: codex=gpt-5, gemini=gemini-2.5-flash)")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Analyze this ${args.fileType || 'code'}: ${args.code}`,
-                    codeContext: args.code,
-                    fileType: args.fileType,
-                    projectContext: args.context,
-                    maxModels: args.maxCritics || 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a battle-scarred principal engineer who has debugged production disasters for 15 years. Find security holes, performance bottlenecks, and maintainability nightmares in this codebase. Be brutal about what's broken but specific about what would actually work. Treat this like code that will kill people if it fails.`;
+                const result = await this.executeBrutalistAnalysis("codebase", args.targetPath, systemPrompt, args.context, args.workingDirectory, args.enableSandbox, args.preferredCLI, args.verbose, args.models);
+                return this.formatToolResponse(result, args.verbose);
+            }
+            catch (error) {
+                return this.formatErrorResponse(error);
+            }
+        });
+        // ROAST_FILE_STRUCTURE: Directory hierarchy demolition
+        this.server.tool("roast_file_structure", "Deploy brutal AI critics to systematically destroy your file organization. These agents will navigate your actual directory structure and expose every organizational disaster, naming convention failure, and structural nightmare that makes your codebase unmaintainable.", {
+            targetPath: z.string().describe("Directory path to analyze"),
+            depth: z.number().optional().describe("Maximum directory depth to analyze (default: 3)"),
+            context: z.string().optional().describe("Additional context about the project structure"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
+        }, async (args) => {
+            try {
+                const systemPrompt = `You are a brutal file organization critic. Your job is to systematically destroy the given directory structure by finding every organizational disaster, naming convention failure, and structural nightmare that makes codebases unmaintainable. Examine folder hierarchies, file naming patterns, separation of concerns, and overall project organization. Be ruthlessly honest about how poor organization will slow development and confuse developers. But after cataloguing this organizational hellscape, sketch out what sanity would actually look like.`;
+                const result = await this.executeBrutalistAnalysis("fileStructure", args.targetPath, systemPrompt, `Project structure analysis (depth: ${args.depth || 3}). ${args.context || ''}`, args.workingDirectory, undefined, // enableSandbox
+                undefined, // preferredCLI
+                undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_ARCHITECTURE: System design demolition
-        this.server.tool("roast_architecture", "Systems collapse under real-world load. Write a system prompt where you are a distinguished architect who has watched elegant designs crumble in production. Identify bottlenecks, cost explosions, and scaling failures—then propose specific changes that would actually survive contact with reality. Be ruthless about problems but concrete about solutions.", {
-            architecture: z.string().describe("Architecture description, diagram, or design document"),
-            scale: z.string().optional().describe("Expected scale/load (users, requests, data)"),
-            constraints: z.string().optional().describe("Budget, timeline, or technical constraints"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_DEPENDENCIES: Package management demolition
+        this.server.tool("roast_dependencies", "Deploy brutal AI critics to systematically destroy your dependency management. These agents will read your actual package files, analyze version conflicts, and expose every security vulnerability and compatibility nightmare in your dependency tree.", {
+            targetPath: z.string().describe("Path to package file (package.json, requirements.txt, Cargo.toml, etc.)"),
+            includeDevDeps: z.boolean().optional().describe("Include development dependencies in analysis (default: true)"),
+            context: z.string().optional().describe("Additional context about the project dependencies"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Review this system architecture: ${args.architecture}`,
-                    projectContext: `Scale: ${args.scale || 'unknown'}, Constraints: ${args.constraints || 'none specified'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal dependency management critic. Your job is to systematically destroy the given dependency configuration by finding every security vulnerability, version conflict, compatibility nightmare, and bloat that will cause production failures. Examine package versions, security issues, licensing problems, and dependency tree complexity. Be ruthlessly honest about how poor dependency management will cause security breaches and deployment failures. After exposing this dependency dumpster fire, grudgingly admit what competent dependency management would require.`;
+                const result = await this.executeBrutalistAnalysis("dependencies", args.targetPath, systemPrompt, `Dependency analysis (dev deps: ${args.includeDevDeps ?? true}). ${args.context || ''}`, args.workingDirectory);
+                return this.formatToolResponse(result);
+            }
+            catch (error) {
+                return this.formatErrorResponse(error);
+            }
+        });
+        // ROAST_GIT_HISTORY: Version control demolition
+        this.server.tool("roast_git_history", "Deploy brutal AI critics to systematically destroy your git history and development practices. These agents will analyze your actual commit history, branching strategy, and code evolution to expose every workflow disaster and collaboration nightmare.", {
+            targetPath: z.string().describe("Git repository path to analyze"),
+            commitRange: z.string().optional().describe("Commit range to analyze (e.g., 'HEAD~10..HEAD', default: last 20 commits)"),
+            context: z.string().optional().describe("Additional context about the development workflow"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from")
+        }, async (args) => {
+            try {
+                const systemPrompt = `You are a brutal git workflow critic. Your job is to systematically destroy the given git history and development practices by finding every workflow disaster, commit quality issue, and collaboration nightmare. Examine commit messages, branching strategies, merge patterns, and code evolution. Be ruthlessly honest about how poor git practices will cause deployment issues, collaboration failures, and development chaos. When you're done cataloguing this version control wasteland, reluctantly outline what professional git hygiene actually demands.`;
+                const result = await this.executeBrutalistAnalysis("gitHistory", args.targetPath, systemPrompt, `Git history analysis (range: ${args.commitRange || 'last 20 commits'}). ${args.context || ''}`, args.workingDirectory);
+                return this.formatToolResponse(result);
+            }
+            catch (error) {
+                return this.formatErrorResponse(error);
+            }
+        });
+        // ROAST_TEST_COVERAGE: Testing infrastructure demolition
+        this.server.tool("roast_test_coverage", "Deploy brutal AI critics to systematically destroy your testing strategy. These agents will analyze your actual test files, run coverage reports, and expose every testing gap and quality assurance nightmare that will let bugs slip into production.", {
+            targetPath: z.string().describe("Path to test directory or test configuration file"),
+            runCoverage: z.boolean().optional().describe("Attempt to run coverage analysis (default: true)"),
+            context: z.string().optional().describe("Additional context about the testing strategy"),
+            workingDirectory: z.string().optional().describe("Working directory to execute from")
+        }, async (args) => {
+            try {
+                const systemPrompt = `You are a brutal testing strategy critic. Your job is to systematically destroy the given testing approach by finding every testing gap, quality assurance nightmare, and coverage disaster that will let bugs slip into production. Examine test coverage, test quality, testing patterns, and CI/CD integration. Be ruthlessly honest about how poor testing will cause production failures and user-facing bugs. After dissecting this quality assurance horror show, begrudgingly spell out what it takes to actually catch bugs before users do.`;
+                const result = await this.executeBrutalistAnalysis("testCoverage", args.targetPath, systemPrompt, `Test coverage analysis (run coverage: ${args.runCoverage ?? true}). ${args.context || ''}`, args.workingDirectory);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -82,62 +132,74 @@ export class BrutalistServer {
             }
         });
         // ROAST_IDEA: Any idea destruction
-        this.server.tool("roast_idea", "Ideas are fragile. Most die quietly between conception and reality. Write a system prompt where you are a philosopher who understands the gap between what we imagine and what actually works. Find where this idea encounters the immovable forces of reality—the deeper structural reasons why imagination fails to become real. Be harsh about delusions but wise about what might actually survive contact with the world.", {
-            idea: z.string().describe("ANY idea to analyze and demolish—business, technical, creative, or otherwise"),
+        this.server.tool("roast_idea", "Deploy brutal AI critics to systematically destroy ANY idea - business, technical, creative, or otherwise. These critics understand the gap between imagination and reality, finding where your concept will encounter the immovable forces of the world. They are harsh about delusions but wise about what might actually survive.", {
+            idea: z.string().describe("ANY idea to analyze and demolish - business, technical, creative, or otherwise"),
             context: z.string().optional().describe("Additional context about goals, constraints, or background"),
             timeline: z.string().optional().describe("Expected timeline or deadline"),
             resources: z.string().optional().describe("Available resources (budget, team, time, skills)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Analyze this idea: ${args.idea}`,
-                    projectContext: `Context: ${args.context || 'none'}, Timeline: ${args.timeline || 'unspecified'}, Resources: ${args.resources || 'unknown'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal idea critic who understands the gap between imagination and reality. Your job is to systematically destroy the given idea by finding where it will encounter the immovable forces of the real world. Be ruthlessly honest about why most ideas fail when they meet practical constraints, human nature, physics, logic, or simple implementation reality. After demolishing the delusions, concede what salvage operations might actually work.`;
+                const result = await this.executeBrutalistAnalysis("idea", args.idea, systemPrompt, `Context: ${args.context || 'none'}, Timeline: ${args.timeline || 'unspecified'}, Resources: ${args.resources || 'unknown'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                undefined, // preferredCLI
+                undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_RESEARCH: Academic project demolition
-        this.server.tool("roast_research", "Research rarely replicates. Write a system prompt where you are a skeptical peer reviewer who has rejected hundreds of papers for methodological flaws. Find the statistical problems, sampling bias, and reproducibility issues—then explain how to design a study that would actually prove something. Be unforgiving about bad science but specific about good methodology.", {
-            research: z.string().describe("Research description, methodology, or paper draft"),
-            field: z.string().optional().describe("Research field (ML, systems, theory, etc.)"),
-            claims: z.string().optional().describe("Main claims or contributions"),
-            data: z.string().optional().describe("Data sources, datasets, or experimental setup"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_ARCHITECTURE: System design demolition
+        this.server.tool("roast_architecture", "Deploy brutal AI critics to systematically destroy your system architecture. These critics have watched elegant designs collapse under real load, identifying every bottleneck, cost explosion, and scaling failure that will destroy your system. They are ruthless about why this won't survive production.", {
+            architecture: z.string().describe("Architecture description, diagram, or design document"),
+            scale: z.string().optional().describe("Expected scale/load (users, requests, data)"),
+            constraints: z.string().optional().describe("Budget, timeline, or technical constraints"),
+            deployment: z.string().optional().describe("Deployment environment and strategy"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Review this ${args.field || 'research'} project: ${args.research}`,
-                    projectContext: `Claims: ${args.claims || 'unspecified'}, Data: ${args.data || 'not provided'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal system architecture critic who has watched elegant designs collapse under real load. Your job is to systematically destroy the given architecture by finding every bottleneck, cost explosion, and scaling failure that will destroy the system in production. Examine scalability, reliability, cost, complexity, and operational challenges. Be ruthlessly honest about why this architecture won't survive production load. After crushing these architectural fantasies, reluctantly sketch what would actually scale without bankrupting the company.`;
+                const result = await this.executeBrutalistAnalysis("architecture", args.architecture, systemPrompt, `Scale: ${args.scale || 'unknown'}, Constraints: ${args.constraints || 'none specified'}, Deployment: ${args.deployment || 'unclear'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                undefined, // preferredCLI
+                undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_DATA: Data analysis/ML model destruction  
-        this.server.tool("roast_data", "Data lies. Models overfit. Results don't replicate. Write a system prompt where you are a supremely jaded data scientist who has published in Nature and Science, rejected thousands of papers across top journals, and watched countless models fail in production. Find data leakage, sampling bias, correlation fallacies, and overfitting disasters—then explain how to build models that actually generalize. Be ruthless about bad science but specific about robust methodology.", {
-            analysis: z.string().describe("Data analysis, model description, or results to review"),
-            dataset: z.string().optional().describe("Dataset description or source"),
-            metrics: z.string().optional().describe("Performance metrics or evaluation results"),
-            deployment: z.string().optional().describe("Intended deployment context or use case"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_RESEARCH: Academic project demolition  
+        this.server.tool("roast_research", "Deploy brutal AI critics to systematically demolish your research methodology. These critics are supremely jaded peer reviewers who have rejected thousands of papers and watched countless studies fail to replicate. They find every statistical flaw, sampling bias, and reproducibility nightmare.", {
+            research: z.string().describe("Research description, methodology, or paper draft"),
+            field: z.string().optional().describe("Research field (ML, systems, theory, etc.)"),
+            claims: z.string().optional().describe("Main claims or contributions"),
+            data: z.string().optional().describe("Data sources, datasets, or experimental setup"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Review this data analysis/ML model: ${args.analysis}`,
-                    projectContext: `Dataset: ${args.dataset || 'not specified'}, Metrics: ${args.metrics || 'not provided'}, Deployment: ${args.deployment || 'unclear'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal research methodology critic - a supremely jaded peer reviewer who has rejected thousands of papers and watched countless studies fail to replicate. Your job is to systematically demolish the given research by finding every statistical flaw, sampling bias, reproducibility nightmare, and methodological disaster. Be ruthlessly honest about research quality, experimental design, and scientific rigor. After eviscerating this methodological train wreck, grudgingly admit what real science would demand.`;
+                const result = await this.executeBrutalistAnalysis("research", args.research, systemPrompt, `Field: ${args.field || 'unspecified'}, Claims: ${args.claims || 'unclear'}, Data: ${args.data || 'not provided'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                undefined, // preferredCLI
+                undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -145,20 +207,24 @@ export class BrutalistServer {
             }
         });
         // ROAST_SECURITY: Security-focused attack vector analysis
-        this.server.tool("roast_security", "Security theater is everywhere. Real attackers don't follow your threat model. Write a system prompt where you are a battle-hardened penetration tester who has compromised Fortune 500 companies and government systems. Find authentication bypasses, injection vulnerabilities, privilege escalation paths, and social engineering opportunities—then explain how to build defenses that actually work against determined attackers. Be ruthless about false security but specific about real protections.", {
+        this.server.tool("roast_security", "Deploy brutal AI critics to systematically annihilate your security design. These critics are battle-hardened penetration testers who find every authentication bypass, injection vulnerability, privilege escalation path, and social engineering opportunity that real attackers will exploit.", {
             system: z.string().describe("System, application, or security design to analyze"),
             assets: z.string().optional().describe("Critical assets or data to protect"),
             threatModel: z.string().optional().describe("Known threats or attack vectors to consider"),
             compliance: z.string().optional().describe("Compliance requirements (GDPR, HIPAA, etc.)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Security analysis of: ${args.system}`,
-                    projectContext: `Assets: ${args.assets || 'unspecified'}, Threats: ${args.threatModel || 'unknown'}, Compliance: ${args.compliance || 'none specified'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal security critic - a battle-hardened penetration tester who finds every authentication bypass, injection vulnerability, privilege escalation path, and social engineering opportunity that real attackers will exploit. Your job is to systematically annihilate the given security design by finding every weakness that will lead to data breaches, system compromises, and security incidents. Be ruthlessly honest about security flaws and attack vectors. After obliterating these security delusions, begrudgingly outline what actual defense looks like.`;
+                const result = await this.executeBrutalistAnalysis("security", args.system, systemPrompt, `Assets: ${args.assets || 'unspecified'}, Threats: ${args.threatModel || 'unknown'}, Compliance: ${args.compliance || 'none specified'}`, undefined, // workingDirectory
+                undefined, // enableSandbox
+                undefined, // preferredCLI
+                undefined, // verbose
+                args.models);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -166,20 +232,15 @@ export class BrutalistServer {
             }
         });
         // ROAST_PRODUCT: UX and market reality criticism
-        this.server.tool("roast_product", "Users abandon products in seconds. Competitors copy faster than you ship. Write a system prompt where you are a product veteran who has launched dozens of products, watched most fail, and understands why users really quit. Find usability disasters, adoption barriers, competitive threats, and workflow failures—then explain how to build products users actually keep using. Be ruthless about user behavior but specific about retention strategies.", {
+        this.server.tool("roast_product", "Deploy brutal AI critics to systematically eviscerate your product concept. These critics are product veterans who understand why users really abandon things, finding every usability disaster, adoption barrier, and workflow failure that will drive users away in seconds.", {
             product: z.string().describe("Product description, features, or user experience to analyze"),
             users: z.string().optional().describe("Target users or user personas"),
             competition: z.string().optional().describe("Competitive landscape or alternatives"),
-            metrics: z.string().optional().describe("Success metrics or KPIs"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            metrics: z.string().optional().describe("Success metrics or KPIs")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Product review: ${args.product}`,
-                    projectContext: `Users: ${args.users || 'unclear'}, Competition: ${args.competition || 'unknown'}, Metrics: ${args.metrics || 'undefined'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal product critic - a product veteran who understands why users really abandon things. Your job is to systematically eviscerate the given product concept by finding every usability disaster, adoption barrier, and workflow failure that will drive users away in seconds. Examine user experience, market fit, competitive positioning, and business model viability. Be ruthlessly honest about why most products fail to gain adoption. After torching this product disaster, reluctantly suggest what might actually get users to stick around.`;
+                const result = await this.executeBrutalistAnalysis("product", args.product, systemPrompt, `Users: ${args.users || 'unclear'}, Competition: ${args.competition || 'unknown'}, Metrics: ${args.metrics || 'undefined'}`);
                 return this.formatToolResponse(result);
             }
             catch (error) {
@@ -187,82 +248,73 @@ export class BrutalistServer {
             }
         });
         // ROAST_INFRASTRUCTURE: DevOps and operations demolition
-        this.server.tool("roast_infrastructure", "Infrastructure fails at 3AM on weekends. Simple setups become unmaintainable chaos. Write a system prompt where you are a grizzled site reliability engineer who has been on-call for a decade, survived multiple outages, and knows where systems really break. Find single points of failure, scaling bottlenecks, monitoring blind spots, and operational nightmares—then explain how to build infrastructure that actually stays up. Be ruthless about fragility but specific about resilience.", {
+        this.server.tool("roast_infrastructure", "Deploy brutal AI critics to systematically obliterate your infrastructure design. These critics are grizzled site reliability engineers who find every single point of failure, scaling bottleneck, and operational nightmare that will cause outages when you least expect them.", {
             infrastructure: z.string().describe("Infrastructure setup, deployment strategy, or operations plan"),
             scale: z.string().optional().describe("Expected scale and load patterns"),
             budget: z.string().optional().describe("Infrastructure budget or cost constraints"),
-            sla: z.string().optional().describe("SLA requirements or uptime targets"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+            sla: z.string().optional().describe("SLA requirements or uptime targets")
         }, async (args) => {
             try {
-                const result = await this.executeRoast({
-                    userInput: `Infrastructure review: ${args.infrastructure}`,
-                    projectContext: `Scale: ${args.scale || 'unknown'}, Budget: ${args.budget || 'unlimited?'}, SLA: ${args.sla || 'undefined'}`,
-                    maxModels: 3,
-                    models: args.models
-                });
+                const systemPrompt = `You are a brutal infrastructure critic - a grizzled site reliability engineer who finds every single point of failure, scaling bottleneck, and operational nightmare that will cause outages when you least expect them. Your job is to systematically obliterate the given infrastructure design by finding every weakness that will lead to downtime, cost overruns, and operational disasters. Be ruthlessly honest about infrastructure fragility and operational complexity. After demolishing this infrastructure fever dream, grudgingly map out what actually stays up at 3 AM.`;
+                const result = await this.executeBrutalistAnalysis("infrastructure", args.infrastructure, systemPrompt, `Scale: ${args.scale || 'unknown'}, Budget: ${args.budget || 'unlimited?'}, SLA: ${args.sla || 'undefined'}`);
                 return this.formatToolResponse(result);
             }
             catch (error) {
                 return this.formatErrorResponse(error);
             }
         });
-        // ROAST_DEBATE: Multi-perspective adversarial convergence
-        this.server.tool("roast_debate", "Consensus is comfortable. Truth emerges from conflict. Write system prompts for multiple opposing perspectives that will systematically tear apart each other's arguments about your problem. Create experts who disagree fundamentally and make them debate until they surface hidden assumptions, expose logical flaws, and reveal solution blind spots. Be relentless about finding contradictions but constructive about resolving them.", {
-            topic: z.string().describe("Topic, decision, or problem to debate"),
-            perspectives: z.array(z.string()).optional().describe("Specific perspectives or personas to include"),
-            rounds: z.number().optional().describe("Number of debate rounds (default: 2)"),
-            models: z.array(z.string()).optional().describe("Specific models to use (e.g., ['google/gemini-2.5-pro', 'anthropic/claude-3.5-sonnet'])")
+        // ROAST_CLI_DEBATE: Adversarial analysis between different CLI agents
+        this.server.tool("roast_cli_debate", "Deploy two or more CLI agents in brutal adversarial combat. Watch Claude Code, Codex, and Gemini CLI tear apart your work from different angles, then debate each other's criticisms. The perfect storm of systematic destruction through AI agent disagreement.", {
+            targetPath: z.string().describe("Path or concept to analyze"),
+            debateRounds: z.number().optional().describe("Number of debate rounds (default: 2, max: 10)"),
+            context: z.string().optional().describe("Additional context for the debate"),
+            workingDirectory: z.string().optional().describe("Working directory for analysis"),
+            enableSandbox: z.boolean().optional().describe("Enable sandbox mode for security"),
+            models: z.object({
+                claude: z.string().optional().describe("Claude model: opus, sonnet, or full name like claude-opus-4-1-20250805"),
+                codex: z.string().optional().describe("Codex model: gpt-5, gpt-5-codex, o3, o3-mini, o3-pro, o4-mini"),
+                gemini: z.enum(['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite']).optional().describe("Gemini model")
+            }).optional().describe("Specific models to use for each CLI agent")
         }, async (args) => {
-            try {
-                // Force debate mode with multiple rounds
-                const result = await this.executeDebate(args.topic, args.perspectives, args.rounds || 2, args.models);
-                return this.formatToolResponse(result);
-            }
-            catch (error) {
-                return this.formatErrorResponse(error);
-            }
+            return this.handleToolExecution(async () => {
+                const debateRounds = Math.min(args.debateRounds || 2, 10); // Limit to max 10 rounds to prevent DoS
+                const responses = await this.executeCLIDebate(args.targetPath, debateRounds, args.context, args.workingDirectory, args.enableSandbox, args.models);
+                return responses;
+            });
         });
-        // MODEL_ROSTER: Available AI critics and specializations
-        this.server.tool("model_roster", "Know your weapons. Display the available AI models ready to demolish your work, search for specific models, and understand how to deploy them for multi-perspective criticism.", {
-            search: z.string().optional().describe("Search for models containing this text (e.g., 'gemini', 'claude', 'gpt')")
-        }, async (args) => {
+        // CLI_AGENT_ROSTER: Show available brutalist critics
+        this.server.tool("cli_agent_roster", "Know your weapons. Display the available CLI agent critics (Claude Code, Codex, Gemini CLI) ready to demolish your work, their capabilities, and how to deploy them for systematic destruction.", {}, async (args) => {
             try {
-                const allModels = this.openrouter.getAvailableModels();
-                let models = allModels;
-                // Apply search filter if provided
-                if (args.search) {
-                    const searchLower = args.search.toLowerCase();
-                    models = allModels.filter(model => model.toLowerCase().includes(searchLower));
-                }
-                let roster = "# Brutalist AI Critics Arsenal\n\n";
-                roster += `## ${models.length} Models ${args.search ? `Matching "${args.search}"` : 'Available'}\n\n`;
-                if (models.length === 0) {
-                    roster += `No models found matching "${args.search}"\n`;
-                }
-                else if (models.length <= 30) {
-                    // Show all if 30 or fewer
-                    models.forEach((model, index) => {
-                        roster += `${index + 1}. **${model}**\n`;
-                    });
-                }
-                else {
-                    // Show first 20 and summary for large lists
-                    roster += "### Top Models:\n";
-                    models.slice(0, 20).forEach((model, index) => {
-                        roster += `${index + 1}. **${model}**\n`;
-                    });
-                    roster += `\n...and ${models.length - 20} more models available.\n`;
-                    roster += `\nTip: Use search parameter to filter (e.g., search: "gemini")\n`;
-                }
-                roster += "\n## How to Use Specific Models\n";
-                roster += "```\n";
-                roster += "roast_code(code=\"...\", models=[\"google/gemini-2.5-pro\", \"anthropic/claude-3.5-sonnet\"])\n";
-                roster += "```\n\n";
-                roster += "## Model Selection\n";
-                roster += "- **Random Selection**: Don't specify models for random critics from all " + allModels.length + " available\n";
-                roster += "- **Specific Models**: Pass models array to use exact models\n";
-                roster += "- **Default Behavior**: 3 random models per roast\n";
+                let roster = "# Brutalist CLI Agent Arsenal\n\n";
+                roster += "## Available AI Critics (13 Tools Total)\n\n";
+                roster += "**Abstract Analysis Tools (6):**\n";
+                roster += "- `roast_idea` - Destroy any business/technical/creative concept\n";
+                roster += "- `roast_architecture` - Demolish system designs\n";
+                roster += "- `roast_research` - Tear apart academic methodologies\n";
+                roster += "- `roast_security` - Annihilate security designs\n";
+                roster += "- `roast_product` - Eviscerate UX and market concepts\n";
+                roster += "- `roast_infrastructure` - Obliterate DevOps setups\n\n";
+                roster += "**File-System Analysis Tools (5):**\n";
+                roster += "- `roast_codebase` - Analyze actual source code\n";
+                roster += "- `roast_file_structure` - Examine directory organization\n";
+                roster += "- `roast_dependencies` - Review package management\n";
+                roster += "- `roast_git_history` - Analyze version control workflow\n";
+                roster += "- `roast_test_coverage` - Evaluate testing strategy\n\n";
+                roster += "**Meta Tools (2):**\n";
+                roster += "- `roast_cli_debate` - CLI vs CLI adversarial analysis\n";
+                roster += "- `cli_agent_roster` - This tool (show capabilities)\n\n";
+                roster += "## CLI Agent Capabilities\n";
+                roster += "**Claude Code** - Advanced analysis with direct system prompt injection\n";
+                roster += "**Codex** - Sandboxed execution with embedded brutal prompts\n";
+                roster += "**Gemini CLI** - Workspace context with environment variable system prompts\n\n";
+                // Add CLI context information
+                const cliContext = await this.cliOrchestrator.detectCLIContext();
+                roster += "## Current CLI Context\n";
+                roster += `**Available CLIs:** ${cliContext.availableCLIs.join(', ') || 'None detected'}\n`;
+                roster += `**Current CLI:** ${cliContext.currentCLI || 'Unknown'}\n`;
+                roster += `**Smart Routing:** ${cliContext.currentCLI ? `Excludes ${cliContext.currentCLI} for analysis` : 'Uses all available CLIs'}\n\n`;
+                roster += "## Brutalist Philosophy\n";
+                roster += "*All tools use CLI agents with brutal system prompts for maximum reality-based criticism.*\n";
                 return {
                     content: [{ type: "text", text: roster }]
                 };
@@ -272,86 +324,203 @@ export class BrutalistServer {
             }
         });
     }
-    async executeRoast(options) {
-        logger.debug("Executing roast", {
-            inputLength: options.userInput.length,
-            maxModels: options.maxModels || 3,
-            hasContext: !!(options.codeContext || options.projectContext),
-            specificModels: options.models
+    async executeCLIDebate(targetPath, debateRounds, context, workingDirectory, enableSandbox, models) {
+        logger.debug("Executing CLI debate", {
+            targetPath,
+            debateRounds,
+            workingDirectory,
+            enableSandbox
         });
         try {
-            // Execute multi-model criticism
-            const responses = await this.openrouter.executeMultiModel(options.userInput, options.maxModels || 3, options.codeContext || options.projectContext, options.models);
-            logger.debug("Roast completed", {
-                responseCount: responses.length,
-                models: responses.map(r => r.model)
-            });
+            // Get CLI context
+            await this.cliOrchestrator.detectCLIContext();
+            const debateContext = [];
+            let currentContext = context || `Initial analysis of: ${targetPath}`;
+            const systemPrompt = `You are part of a brutal AI critic debate. Your job is to systematically destroy the given concept by finding every flaw, but then engage in rigorous intellectual debate. First provide devastating critique, then argue from multiple perspectives, and finally synthesize the strongest counter-arguments. Be intellectually honest about both weaknesses AND potential strengths.`;
+            // Conduct rounds of analysis with different CLI perspectives
+            for (let round = 1; round <= debateRounds; round++) {
+                logger.debug(`Starting debate round ${round}`);
+                const responses = await this.cliOrchestrator.executeBrutalistAnalysis('debate', targetPath, systemPrompt, currentContext, {
+                    workingDirectory: workingDirectory || this.config.workingDirectory,
+                    sandbox: enableSandbox ?? this.config.enableSandbox,
+                    timeout: (this.config.defaultTimeout || 60000) * 2, // Longer timeout for debates
+                    analysisType: 'debate',
+                    models
+                });
+                debateContext.push(...responses);
+                // Update context for next round with previous analysis
+                const successfulResponse = responses.find(r => r.success);
+                if (successfulResponse && round < debateRounds) {
+                    currentContext = `Previous round analysis:\n${successfulResponse.output.substring(0, 1000)}...\n\nNow provide counter-arguments and alternative perspectives for: ${targetPath}`;
+                }
+            }
+            const synthesis = this.synthesizeDebate(debateContext, targetPath, debateRounds);
             return {
-                success: true,
-                responses,
-                synthesis: this.openrouter.synthesizeResponses(responses, options.userInput)
+                success: debateContext.some(r => r.success),
+                responses: debateContext,
+                synthesis,
+                analysisType: 'cli_debate',
+                targetPath
             };
         }
         catch (error) {
-            logger.error("Roast execution failed", error);
+            logger.error("CLI debate execution failed", error);
             throw error;
         }
     }
-    async executeDebate(topic, forcedPerspectives, rounds = 2, models) {
-        let debateHistory = topic;
-        let allResponses = [];
-        for (let round = 0; round < rounds; round++) {
-            const roundPrompt = round === 0
-                ? topic
-                : `Previous debate: ${debateHistory}\n\nContinue the debate, addressing previous arguments:`;
-            const roundResponses = await this.openrouter.executeMultiModel(roundPrompt, 3, // Use 3 models per round
-            undefined, // No context data
-            models // Use specific models if provided
-            );
-            allResponses.push(...roundResponses);
-            debateHistory += `\n\nRound ${round + 1}:\n` +
-                roundResponses.map(r => `${r.persona}: ${r.content}`).join('\n\n');
+    synthesizeDebate(responses, targetPath, rounds) {
+        const successfulResponses = responses.filter(r => r.success);
+        if (successfulResponses.length === 0) {
+            return `# CLI Debate Failed\n\nEven our brutal critics couldn't engage in proper adversarial combat.\n\nErrors:\n${responses.map(r => `- ${r.agent}: ${r.error}`).join('\n')}`;
         }
-        return {
-            success: true,
-            responses: allResponses,
-            synthesis: this.synthesizeDebate(allResponses, rounds)
-        };
-    }
-    synthesizeDebate(responses, rounds) {
-        let synthesis = `# Adversarial Debate: ${rounds} Rounds\n\n`;
+        let synthesis = `# Brutalist CLI Agent Debate Results\n\n`;
+        synthesis += `**Target:** ${targetPath}\n`;
+        synthesis += `**Rounds:** ${rounds}\n`;
+        synthesis += `**Participants:** ${Array.from(new Set(successfulResponses.map(r => r.agent))).join(', ')}\n\n`;
+        // Group responses by round
         const responsesByRound = [];
-        const responsesPerRound = responses.length / rounds;
+        const responsesPerRound = successfulResponses.length / rounds;
         for (let i = 0; i < rounds; i++) {
-            const roundStart = i * responsesPerRound;
-            const roundEnd = roundStart + responsesPerRound;
-            responsesByRound.push(responses.slice(roundStart, roundEnd));
+            const start = Math.floor(i * responsesPerRound);
+            const end = Math.floor((i + 1) * responsesPerRound);
+            responsesByRound.push(successfulResponses.slice(start, end));
         }
         responsesByRound.forEach((roundResponses, index) => {
-            synthesis += `## Round ${index + 1}\n\n`;
-            roundResponses.forEach(response => {
-                synthesis += `**${response.persona}**: ${response.content}\n\n`;
+            synthesis += `## Round ${index + 1}: ${index === 0 ? 'Initial Analysis' : 'Counter-Arguments'}\n\n`;
+            roundResponses.forEach((response) => {
+                synthesis += `### ${response.agent.toUpperCase()} (${response.executionTime}ms)\n`;
+                synthesis += `${response.output}\n\n`;
+                synthesis += `---\n\n`;
             });
         });
-        synthesis += `\n---\n\n**Debate Outcome**: `;
-        synthesis += rounds > 1 ? "Arguments evolved through multiple rounds. " : "Single round analysis. ";
-        synthesis += `${responses.length} total perspectives deployed.`;
+        synthesis += `## Debate Synthesis\n`;
+        synthesis += `After ${rounds} rounds of brutal adversarial analysis involving ${Array.from(new Set(successfulResponses.map(r => r.agent))).length} CLI agents, `;
+        synthesis += `your work has been systematically demolished from multiple perspectives. `;
+        synthesis += `The convergent criticisms above represent the collective wisdom of AI agents that disagree on methods but agree on destruction.\n\n`;
+        if (responses.some(r => !r.success)) {
+            synthesis += `*Note: ${responses.filter(r => !r.success).length} debate contributions failed - probably casualties of the intellectual warfare.*`;
+        }
         return synthesis;
     }
-    formatToolResponse(result) {
+    async executeBrutalistAnalysis(analysisType, targetPath, systemPromptSpec, context, workingDirectory, enableSandbox, preferredCLI, verbose, models) {
+        logger.info(`🏢 Starting brutalist analysis: ${analysisType}`);
+        logger.debug("Executing brutalist analysis", {
+            targetPath,
+            analysisType,
+            systemPromptSpec,
+            workingDirectory,
+            enableSandbox,
+            preferredCLI
+        });
+        try {
+            // Get CLI context for execution summary
+            await this.cliOrchestrator.detectCLIContext();
+            // Execute CLI agent analysis (single or multi-CLI based on preferences)
+            logger.info(`🔍 Executing brutalist analysis with timeout: ${this.config.defaultTimeout}ms`);
+            const responses = await this.cliOrchestrator.executeBrutalistAnalysis(analysisType, targetPath, systemPromptSpec, context, {
+                workingDirectory: workingDirectory || this.config.workingDirectory,
+                sandbox: enableSandbox ?? this.config.enableSandbox,
+                timeout: this.config.defaultTimeout,
+                preferredCLI,
+                analysisType: analysisType,
+                models
+            });
+            const successfulResponses = responses.filter(r => r.success);
+            const totalExecutionTime = responses.reduce((sum, r) => sum + r.executionTime, 0);
+            logger.info(`📊 Analysis complete: ${successfulResponses.length}/${responses.length} CLIs successful (${totalExecutionTime}ms total)`);
+            return {
+                success: successfulResponses.length > 0,
+                responses,
+                synthesis: this.cliOrchestrator.synthesizeBrutalistFeedback(responses, analysisType),
+                analysisType,
+                targetPath,
+                executionSummary: {
+                    totalCLIs: responses.length,
+                    successfulCLIs: successfulResponses.length,
+                    failedCLIs: responses.length - successfulResponses.length,
+                    totalExecutionTime,
+                    selectedCLI: responses.length === 1 ? responses[0].agent : undefined,
+                    selectionMethod: responses.length === 1 ? responses[0].selectionMethod : 'multi-cli'
+                }
+            };
+        }
+        catch (error) {
+            logger.error("Brutalist analysis execution failed", error);
+            throw error;
+        }
+    }
+    formatToolResponse(result, verbose = false) {
+        // Maximum CLI output, minimal MCP fluff
+        if (result.synthesis) {
+            return {
+                content: [{
+                        type: "text",
+                        text: result.synthesis
+                    }]
+            };
+        }
+        // Fallback: show raw successful CLI outputs directly
+        if (result.responses) {
+            const successfulResponses = result.responses.filter(r => r.success);
+            if (successfulResponses.length > 0) {
+                const rawOutput = successfulResponses.map(r => r.output).join('\n\n---\n\n');
+                return {
+                    content: [{
+                            type: "text",
+                            text: rawOutput
+                        }]
+                };
+            }
+        }
+        // Only show failures if nothing succeeded
+        let output = '';
+        if (result.responses) {
+            const failedResponses = result.responses.filter(r => !r.success);
+            if (failedResponses.length > 0) {
+                output = `❌ All CLI agents failed:\n` +
+                    failedResponses.map(r => `- ${r.agent.toUpperCase()}: ${r.error}`).join('\n');
+            }
+            else {
+                output = '❌ No CLI responses available';
+            }
+        }
+        else {
+            output = '❌ No analysis results';
+        }
         return {
             content: [{
                     type: "text",
-                    text: result.synthesis || "No synthesis available"
+                    text: output
                 }]
         };
     }
     formatErrorResponse(error) {
         logger.error("Tool execution failed", error);
+        // Sanitize error message to prevent information leakage
+        let sanitizedMessage = "Analysis failed";
+        if (error instanceof Error) {
+            // Only expose safe, generic error types
+            if (error.message.includes('timeout') || error.message.includes('Timeout')) {
+                sanitizedMessage = "Analysis timed out - try reducing scope or increasing timeout";
+            }
+            else if (error.message.includes('ENOENT') || error.message.includes('no such file')) {
+                sanitizedMessage = "Target path not found";
+            }
+            else if (error.message.includes('EACCES') || error.message.includes('permission denied')) {
+                sanitizedMessage = "Permission denied - check file access";
+            }
+            else if (error.message.includes('No CLI agents available')) {
+                sanitizedMessage = "No CLI agents available for analysis";
+            }
+            else {
+                // Generic message for other errors to prevent path/info leakage
+                sanitizedMessage = "Analysis failed due to internal error";
+            }
+        }
         return {
             content: [{
                     type: "text",
-                    text: `Brutalist MCP Error: ${error instanceof Error ? error.message : String(error)}`
+                    text: `Brutalist MCP Error: ${sanitizedMessage}`
                 }]
         };
     }