ai-debug-local-mcp
Version:
🎯 ENHANCED AI GUIDANCE v4.1.2: Dramatically improved tool descriptions help AI users choose the right tools instead of 'close enough' options. Ultra-fast keyboard automation (10x speed), universal recording, multi-ecosystem debugging support, and compreh
391 lines • 16.5 kB
JavaScript
/**
* Debug Orchestrator - Real Implementation
* High-level debugging coordination with actual sub-agent execution
*/
import { SubAgentExecutor } from '../sub-agents/sub-agent-executor.js';
export class DebugOrchestrator {
name = 'debug_orchestrator';
description = `STRATEGIC DEBUG COORDINATOR. Orchestrates complex debugging sessions across multiple sub-agents for systematic issue identification.`;
subAgentExecutor;
subAgents = {
frontend: 'debug_discovery_agent',
backend: 'backend_debug_agent',
performance: 'performance_analysis_agent',
error: 'error_investigation_agent',
visual: 'visual_analysis_agent',
test: 'validation_testing_agent',
accessibility: 'accessibility_audit_agent'
};
async orchestrate(task) {
const startTime = Date.now();
console.error('🎯 Debug Orchestrator: Analyzing task...');
try {
// Initialize sub-agent executor if handler provided
if (!this.subAgentExecutor && task.handler) {
this.subAgentExecutor = new SubAgentExecutor(task.handler);
console.error(' ✅ Sub-agent executor initialized');
}
// 1. Analyze what kind of debugging is needed
const analysis = this.analyzeTask(task);
console.error(` 📊 Analysis: ${analysis.primaryDomain} (confidence: ${analysis.confidence})`);
// 2. Create execution plan
const plan = this.createExecutionPlan(analysis, task);
console.error(` 📋 Execution plan: ${plan.steps.length} tasks`);
// 3. Execute plan with sub-agents
const results = await this.executePlan(plan);
// 4. Synthesize results
const synthesis = this.synthesizeResults(results);
console.error(` ✅ Debug orchestration complete in ${Date.now() - startTime}ms`);
return synthesis;
}
catch (error) {
console.error(' ❌ Orchestration failed:', error);
return {
success: false,
summary: `Debug orchestration failed: ${error instanceof Error ? error.message : String(error)}`,
metadata: {
duration: Date.now() - startTime,
error: error instanceof Error ? error.message : String(error),
agentsUsed: [],
confidence: 0
}
};
}
}
analyzeTask(task) {
const text = [
task.task,
task.description,
task.url,
task.errorMessage,
...(task.symptoms || [])
].filter(Boolean).join(' ').toLowerCase();
const keywords = text.split(/\s+/);
const analysis = {
primaryDomain: 'frontend',
subDomains: [],
confidence: 0.5,
suggestedAgents: []
};
// Detect primary debugging domain
if (keywords.includes('slow') || keywords.includes('performance')) {
analysis.primaryDomain = 'performance';
analysis.suggestedAgents.push(this.subAgents.performance);
}
else if (keywords.includes('error') || keywords.includes('crash') || keywords.includes('bug')) {
analysis.primaryDomain = 'error';
analysis.suggestedAgents.push(this.subAgents.error);
}
else if (keywords.includes('look') || keywords.includes('visual') || keywords.includes('ui')) {
analysis.primaryDomain = 'visual';
analysis.suggestedAgents.push(this.subAgents.visual);
}
else if (keywords.includes('api') || keywords.includes('backend') || keywords.includes('server')) {
analysis.primaryDomain = 'backend';
analysis.suggestedAgents.push(this.subAgents.backend);
}
else {
analysis.primaryDomain = 'frontend';
analysis.suggestedAgents.push(this.subAgents.frontend);
}
// Detect secondary domains
if (task.url) {
analysis.subDomains.push('web-based');
if (!analysis.suggestedAgents.includes(this.subAgents.frontend)) {
analysis.suggestedAgents.push(this.subAgents.frontend);
}
}
if (task.errorMessage) {
analysis.subDomains.push('has-errors');
if (!analysis.suggestedAgents.includes(this.subAgents.error)) {
analysis.suggestedAgents.push(this.subAgents.error);
}
}
// Add accessibility check for web-based tasks
if (task.url && !keywords.includes('performance')) {
analysis.suggestedAgents.push(this.subAgents.accessibility);
}
analysis.confidence = analysis.suggestedAgents.length > 0 ? 0.8 : 0.3;
return analysis;
}
createExecutionPlan(analysis, task) {
const steps = [];
// Always start with basic diagnostics
steps.push({
agent: this.subAgents.frontend,
action: 'initial_diagnosis',
context: {
...task,
captureScreenshot: true,
checkConsole: true,
detectFramework: true
},
priority: 'critical',
tools: ['inject_debugging', 'take_screenshot', 'get_console_logs']
});
// Add domain-specific steps
switch (analysis.primaryDomain) {
case 'performance':
steps.push({
agent: this.subAgents.performance,
action: 'full_performance_audit',
context: {
...task,
metrics: ['LCP', 'FCP', 'CLS', 'TTI'],
profile: true,
suggestions: true
},
priority: 'high',
tools: ['run_audit', 'performance_profile']
});
break;
case 'error':
steps.push({
agent: this.subAgents.error,
action: 'investigate_errors',
context: {
...task,
captureStack: true,
traceOrigin: true,
suggestFixes: true
},
priority: 'critical',
tools: ['get_console_logs', 'monitor_realtime', 'analyze_with_ai']
});
break;
case 'visual':
steps.push({
agent: this.subAgents.visual,
action: 'visual_analysis',
context: {
...task,
captureFullPage: true,
detectIssues: true,
compareToBaseline: false
},
priority: 'medium',
tools: ['take_screenshot', 'run_audit']
});
break;
case 'backend':
steps.push({
agent: this.subAgents.backend,
action: 'analyze_backend_issues',
context: {
...task,
checkAPIs: true,
monitorNetwork: true
},
priority: 'high',
tools: ['monitor_realtime', 'mock_network']
});
break;
}
// Add accessibility check if web-based
if (analysis.subDomains.includes('web-based')) {
steps.push({
agent: this.subAgents.accessibility,
action: 'accessibility_audit',
context: task,
priority: 'low',
tools: ['run_audit']
});
}
// Add validation step
steps.push({
agent: this.subAgents.test,
action: 'validate_findings',
context: {
...task,
previousFindings: 'will be populated from results'
},
priority: 'medium',
tools: ['run_tests_with_coverage', 'test_impact_analysis']
});
return {
steps,
parallel: false,
estimatedDuration: steps.length * 5 // 5 seconds per step
};
}
async executePlan(plan) {
if (!this.subAgentExecutor) {
console.warn(' ⚠️ No sub-agent executor available, using fallback');
return this.executePlanFallback(plan);
}
try {
// Execute all tasks through the sub-agent executor
const results = await this.subAgentExecutor.executeTasks(plan.steps);
// Log results
results.forEach(result => {
const icon = result.success ? '✅' : '❌';
console.log(` ${icon} ${result.agent}: ${result.summary}`);
// Log key findings
if (result.data.findings && result.data.findings.length > 0) {
const critical = result.data.findings.filter(f => f.severity === 'critical');
if (critical.length > 0) {
console.error(` 🚨 ${critical.length} critical issues found`);
}
}
});
return results;
}
catch (error) {
console.error(' ❌ Sub-agent execution failed:', error);
return this.executePlanFallback(plan);
}
}
async executePlanFallback(plan) {
console.error(' ⚠️ Using fallback execution (no real tools available)');
const results = [];
for (const step of plan.steps) {
results.push({
agent: step.agent,
action: step.action,
success: true,
summary: `[Simulated] Completed ${step.action}`,
data: {
findings: [{
type: 'info',
severity: 'info',
message: 'Using fallback execution - initialize sub-agent executor for real results'
}],
metrics: {},
suggestions: ['Ensure UniversalRealHandler is properly initialized']
},
duration: 100
});
}
return results;
}
synthesizeResults(results) {
// Aggregate findings from all sub-agents
const allFindings = results.flatMap(r => r.data.findings || []);
const allSuggestions = results.flatMap(r => r.data.suggestions || []);
const allMetrics = results.reduce((acc, r) => ({ ...acc, ...r.data.metrics }), {});
// Group findings by severity
const findings = {
critical: allFindings.filter(f => f.severity === 'critical'),
warnings: allFindings.filter(f => f.severity === 'warning'),
info: allFindings.filter(f => f.severity === 'info')
};
// Create concise summary
const summary = this.createSummary(results, findings);
// Determine next steps based on findings
const nextSteps = this.determineNextSteps(findings, allMetrics);
// Calculate overall confidence
const confidence = this.calculateConfidence(results);
return {
success: results.every(r => r.success),
summary,
findings,
suggestions: this.prioritizeSuggestions(allSuggestions),
nextSteps,
metadata: {
duration: results.reduce((sum, r) => sum + r.duration, 0),
agentsUsed: results.map(r => r.agent),
toolsUsed: results.flatMap(r => r.toolsUsed || []),
confidence,
metrics: allMetrics
}
};
}
createSummary(results, findings) {
const summaryParts = [];
// Add critical findings first
if (findings.critical.length > 0) {
summaryParts.push(`🚨 ${findings.critical.length} critical issues found`);
}
// Add performance issues
const performanceResult = results.find(r => r.agent.includes('performance'));
if (performanceResult && performanceResult.data.metrics) {
const metrics = performanceResult.data.metrics;
if (metrics.performance && metrics.performance < 50) {
summaryParts.push(`⚡ Poor performance score: ${metrics.performance}%`);
}
}
// Add error summary
const errorResult = results.find(r => r.agent.includes('error'));
if (errorResult && errorResult.data.metrics && errorResult.data.metrics.errorCount > 0) {
summaryParts.push(`🐛 ${errorResult.data.metrics.errorCount} errors detected`);
}
// Add accessibility issues
const a11yResult = results.find(r => r.agent.includes('accessibility'));
if (a11yResult && a11yResult.data.metrics && a11yResult.data.metrics.accessibility < 90) {
summaryParts.push(`♿ Accessibility score: ${a11yResult.data.metrics.accessibility}%`);
}
if (summaryParts.length === 0) {
return "✅ No significant issues found. Application appears to be functioning normally.";
}
return summaryParts.join(' | ');
}
determineNextSteps(findings, metrics) {
const steps = [];
// Critical issues take priority
if (findings.critical.length > 0) {
steps.push('🚨 Fix critical issues immediately');
steps.push('💡 Run fix_orchestrator to apply automated fixes');
}
// Performance issues
if (metrics.performance && metrics.performance < 80) {
steps.push('⚡ Run performance_orchestrator for detailed optimization');
}
// Accessibility issues
if (metrics.accessibility && metrics.accessibility < 90) {
steps.push('♿ Run qa_orchestrator for accessibility improvements');
}
// Testing recommendations
if (findings.warnings.length > 0) {
steps.push('🧪 Run test_orchestrator to validate fixes');
}
// General recommendations
if (steps.length === 0) {
steps.push('✅ Continue monitoring with monitor_realtime');
steps.push('📊 Set up regular audits with run_audit');
}
return steps;
}
calculateConfidence(results) {
const successRate = results.filter(r => r.success).length / results.length;
const hasMetrics = results.some(r => Object.keys(r.data.metrics || {}).length > 0);
const hasFindings = results.some(r => (r.data.findings || []).length > 0);
let confidence = successRate * 0.5;
if (hasMetrics)
confidence += 0.25;
if (hasFindings)
confidence += 0.25;
return Math.min(confidence, 1.0);
}
prioritizeSuggestions(suggestions) {
// Remove duplicates and prioritize
const unique = [...new Set(suggestions)];
return unique.map((suggestion, index) => ({
id: `suggestion-${index}`,
title: suggestion,
priority: this.getSuggestionPriority(suggestion),
effort: this.estimateEffort(suggestion)
})).sort((a, b) => {
const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
return priorityOrder[a.priority] - priorityOrder[b.priority];
});
}
getSuggestionPriority(suggestion) {
const lower = suggestion.toLowerCase();
if (lower.includes('critical') || lower.includes('immediately'))
return 'critical';
if (lower.includes('error') || lower.includes('fix'))
return 'high';
if (lower.includes('performance') || lower.includes('optimize'))
return 'medium';
return 'low';
}
estimateEffort(suggestion) {
const lower = suggestion.toLowerCase();
if (lower.includes('simple') || lower.includes('quick'))
return 'low';
if (lower.includes('complex') || lower.includes('refactor'))
return 'high';
return 'medium';
}
}
//# sourceMappingURL=debug-orchestrator-real.js.map