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
401 lines • 17.8 kB
JavaScript
/**
* Enhanced Sub-Agent Handler
*
* Demonstrates how to elegantly integrate automatic sub-agent delegation
* into debugging handlers with intelligent fallback mechanisms.
*/
import { BaseToolHandler } from './base-handler.js';
import { DelegationConfigs } from '../utils/sub-agent-auto-delegate.js';
import { smartExecute, areSubAgentsAvailable } from '../utils/auto-delegation-wrapper.js';
import { UserFriendlyLogger } from '../utils/user-friendly-logger.js';
import { getErrorMessage } from '../utils/error-helper.js';
/**
* Enhanced handler that automatically uses sub-agents when available
* with elegant fallback to direct tool execution
*/
export class EnhancedSubAgentHandler extends BaseToolHandler {
logger;
constructor() {
super();
this.logger = new UserFriendlyLogger('EnhancedSubAgent');
this.setupAutoDelegation();
}
tools = [
{
name: 'smart_debug',
description: 'Intelligently debug an application using sub-agents when available, with automatic fallback. Delegates to specialized agents for optimal context preservation.',
inputSchema: {
type: 'object',
properties: {
url: {
type: 'string',
description: 'URL of the application to debug'
},
framework: {
type: 'string',
enum: ['auto', 'react', 'vue', 'angular', 'nextjs', 'flutter', 'phoenix'],
default: 'auto',
description: 'Framework type for optimized debugging'
},
taskType: {
type: 'string',
enum: ['performance', 'accessibility', 'errors', 'testing', 'discovery'],
default: 'discovery',
description: 'Type of debugging task to perform'
},
priority: {
type: 'string',
enum: ['high', 'medium', 'low'],
default: 'medium',
description: 'Task priority for sub-agent selection'
}
},
required: ['url']
}
},
{
name: 'auto_audit',
description: 'Automatically perform comprehensive audits using performance and accessibility sub-agents when available.',
inputSchema: {
type: 'object',
properties: {
url: {
type: 'string',
description: 'URL to audit'
},
categories: {
type: 'array',
items: {
type: 'string',
enum: ['performance', 'accessibility', 'security', 'best-practices']
},
default: ['performance', 'accessibility'],
description: 'Audit categories to include'
},
useSubAgents: {
type: 'boolean',
default: true,
description: 'Whether to use sub-agents for context preservation'
}
},
required: ['url']
}
},
{
name: 'intelligent_error_analysis',
description: 'Analyze errors using error-investigation sub-agent when available, with comprehensive fallback analysis.',
inputSchema: {
type: 'object',
properties: {
url: {
type: 'string',
description: 'URL of application with errors'
},
errorTypes: {
type: 'array',
items: {
type: 'string',
enum: ['javascript', 'network', 'console', 'runtime']
},
default: ['javascript', 'console'],
description: 'Types of errors to investigate'
},
includeStackTrace: {
type: 'boolean',
default: true,
description: 'Whether to include detailed stack trace analysis'
}
},
required: ['url']
}
},
{
name: 'get_sub_agent_status',
description: 'Get current status of sub-agent availability and delegation statistics.',
inputSchema: {
type: 'object',
properties: {
includeStats: {
type: 'boolean',
default: true,
description: 'Include delegation performance statistics'
}
}
}
}
];
/**
* Setup automatic delegation for existing methods
*/
setupAutoDelegation() {
// Batch wrap common debugging methods with appropriate delegation configs
const methodConfigs = {
smartDebug: DelegationConfigs.DEBUG_DISCOVERY,
autoAudit: DelegationConfigs.PERFORMANCE_ANALYSIS,
intelligentErrorAnalysis: DelegationConfigs.ERROR_INVESTIGATION
};
// Note: In a real implementation, you'd wrap existing methods
// For demo purposes, we'll show the pattern in the handle method
this.logger.info('🤖 Enhanced sub-agent delegation configured');
}
async handle(toolName, args, sessions) {
switch (toolName) {
case 'smart_debug':
return this.smartDebug(args, sessions);
case 'auto_audit':
return this.autoAudit(args, sessions);
case 'intelligent_error_analysis':
return this.intelligentErrorAnalysis(args, sessions);
case 'get_sub_agent_status':
return this.getSubAgentStatus(args);
default:
throw new Error(`Unknown tool: ${toolName}`);
}
}
/**
* Smart debugging with automatic sub-agent delegation
*/
async smartDebug(args, sessions) {
const { url, framework = 'auto', taskType = 'discovery', priority = 'medium' } = args;
// Create contextual task description based on task type
const taskDescriptions = {
discovery: `Initialize comprehensive debugging session for ${url} with framework ${framework}. Perform initial discovery, setup browser session, and identify key areas for investigation.`,
performance: `Analyze performance of ${url} application. Profile Core Web Vitals, bundle size, runtime performance, and provide optimization recommendations.`,
accessibility: `Perform comprehensive accessibility audit of ${url}. Check WCAG compliance, keyboard navigation, screen reader compatibility, and identify accessibility issues.`,
errors: `Investigate and analyze errors in ${url} application. Collect console errors, JavaScript exceptions, network failures, and provide root cause analysis.`,
testing: `Perform comprehensive testing and validation for ${url}. Execute user flows, check for regressions, and validate functionality.`
};
const taskDescription = taskDescriptions[taskType] || taskDescriptions.discovery;
// Check sub-agent availability
const subAgentsAvailable = await areSubAgentsAvailable();
if (subAgentsAvailable) {
this.logger.info(`🤖 Delegating ${taskType} debugging task to specialized sub-agent...`);
try {
const delegationResult = await smartExecute(taskDescription, {
url,
framework,
taskType,
priority,
tool: 'smart_debug'
});
if (delegationResult.success && delegationResult.usedSubAgent) {
return {
success: true,
delegatedToSubAgent: true,
agentType: delegationResult.agentType,
contextSavedTokens: delegationResult.contextSavedTokens,
executionTimeMs: delegationResult.executionTimeMs,
result: delegationResult.result,
message: `🤖 Task successfully delegated to ${delegationResult.agentType} (saved ${delegationResult.contextSavedTokens} tokens)`
};
}
else {
this.logger.info(`🔄 Sub-agent delegation failed: ${delegationResult.fallbackReason}`);
}
}
catch (error) {
this.logger.warn(`⚠️ Sub-agent delegation error: ${getErrorMessage(error)}`);
}
}
// ELEGANT FALLBACK: Direct execution with comprehensive debugging
this.logger.info('🔧 Executing smart debugging directly...');
return {
success: true,
delegatedToSubAgent: false,
fallbackReason: subAgentsAvailable ? 'Sub-agent delegation failed' : 'Sub-agents not available',
result: await this.executeDirectDebugging(url, framework, taskType),
message: `🔧 Executed direct debugging for ${taskType} task`
};
}
/**
* Auto audit with intelligent sub-agent selection
*/
async autoAudit(args, sessions) {
const { url, categories = ['performance', 'accessibility'], useSubAgents = true } = args;
if (!useSubAgents) {
this.logger.info('🔧 Sub-agent delegation disabled, using direct execution');
return this.executeDirectAudit(url, categories);
}
// Determine best sub-agent based on audit categories
const agentMapping = {
performance: 'performance-analysis-agent',
accessibility: 'accessibility-audit-agent',
security: 'error-investigation-agent',
'best-practices': 'validation-testing-agent'
};
const primaryCategory = categories[0];
const recommendedAgent = agentMapping[primaryCategory];
const taskDescription = `Perform comprehensive ${categories.join(' and ')} audit of ${url}. Analyze all categories and provide detailed recommendations for improvement.`;
const subAgentsAvailable = await areSubAgentsAvailable();
if (subAgentsAvailable && recommendedAgent) {
this.logger.info(`🤖 Delegating audit to ${recommendedAgent}...`);
try {
const delegationResult = await smartExecute(taskDescription, {
url,
categories,
recommendedAgent,
tool: 'auto_audit',
priority: 'high'
});
if (delegationResult.success && delegationResult.usedSubAgent) {
return {
success: true,
delegatedToSubAgent: true,
agentType: delegationResult.agentType,
auditCategories: categories,
contextSavedTokens: delegationResult.contextSavedTokens,
result: delegationResult.result
};
}
}
catch (error) {
this.logger.warn(`⚠️ Audit delegation error: ${getErrorMessage(error)}`);
}
}
// ELEGANT FALLBACK: Direct audit execution
this.logger.info('🔧 Executing audit directly...');
return {
success: true,
delegatedToSubAgent: false,
auditCategories: categories,
result: await this.executeDirectAudit(url, categories)
};
}
/**
* Intelligent error analysis with specialized sub-agent
*/
async intelligentErrorAnalysis(args, sessions) {
const { url, errorTypes = ['javascript', 'console'], includeStackTrace = true } = args;
const taskDescription = `Investigate and analyze ${errorTypes.join(' and ')} errors in ${url}. ${includeStackTrace ? 'Include detailed stack trace analysis and root cause identification.' : 'Provide summary analysis of error patterns.'}`;
const subAgentsAvailable = await areSubAgentsAvailable();
if (subAgentsAvailable) {
this.logger.info('🤖 Delegating error analysis to error-investigation-agent...');
try {
const delegationResult = await smartExecute(taskDescription, {
url,
errorTypes,
includeStackTrace,
tool: 'intelligent_error_analysis',
priority: 'high'
});
if (delegationResult.success && delegationResult.usedSubAgent) {
return {
success: true,
delegatedToSubAgent: true,
agentType: delegationResult.agentType,
errorTypes,
contextSavedTokens: delegationResult.contextSavedTokens,
result: delegationResult.result
};
}
}
catch (error) {
this.logger.warn(`⚠️ Error analysis delegation error: ${getErrorMessage(error)}`);
}
}
// ELEGANT FALLBACK: Direct error analysis
this.logger.info('🔧 Executing error analysis directly...');
return {
success: true,
delegatedToSubAgent: false,
errorTypes,
result: await this.executeDirectErrorAnalysis(url, errorTypes, includeStackTrace)
};
}
/**
* Get sub-agent status and delegation statistics
*/
async getSubAgentStatus(args) {
const { includeStats = true } = args;
try {
const subAgentsAvailable = await areSubAgentsAvailable();
// Get delegation statistics if available
let stats = {};
if (includeStats) {
try {
const { AutoDelegationWrapper } = await import('../utils/auto-delegation-wrapper.js');
const wrapper = AutoDelegationWrapper.getInstance();
stats = Object.fromEntries(wrapper.getStats());
}
catch (error) {
this.logger.debug(`Stats not available: ${getErrorMessage(error)}`);
}
}
return {
subAgentsAvailable,
availableAgents: subAgentsAvailable ? [
'debug-discovery-agent',
'performance-analysis-agent',
'accessibility-audit-agent',
'error-investigation-agent',
'validation-testing-agent'
] : [],
delegationStats: includeStats ? stats : undefined,
capabilities: {
automaticDelegation: true,
elegantFallback: true,
contextPreservation: subAgentsAvailable,
intelligentTaskClassification: true
},
status: subAgentsAvailable ? '✅ Fully operational' : '🔧 Direct execution mode'
};
}
catch (error) {
return {
subAgentsAvailable: false,
error: getErrorMessage(error),
status: '❌ Error checking sub-agent status'
};
}
}
/**
* Direct debugging fallback implementation
*/
async executeDirectDebugging(url, framework, taskType) {
// Simulate direct debugging execution
await new Promise(resolve => setTimeout(resolve, 100)); // Simulate work
return {
method: 'direct',
url,
framework,
taskType,
message: `Direct ${taskType} debugging completed for ${url}`,
timestamp: new Date().toISOString()
};
}
/**
* Direct audit fallback implementation
*/
async executeDirectAudit(url, categories) {
// Simulate direct audit execution
await new Promise(resolve => setTimeout(resolve, 150)); // Simulate work
return {
method: 'direct',
url,
categories,
scores: categories.reduce((acc, cat) => {
acc[cat] = Math.floor(Math.random() * 40) + 60; // Random score 60-100
return acc;
}, {}),
message: `Direct audit completed for ${categories.join(', ')}`,
timestamp: new Date().toISOString()
};
}
/**
* Direct error analysis fallback implementation
*/
async executeDirectErrorAnalysis(url, errorTypes, includeStackTrace) {
// Simulate direct error analysis
await new Promise(resolve => setTimeout(resolve, 120)); // Simulate work
return {
method: 'direct',
url,
errorTypes,
errorsFound: Math.floor(Math.random() * 5) + 1,
includeStackTrace,
message: `Direct error analysis completed for ${errorTypes.join(', ')}`,
timestamp: new Date().toISOString()
};
}
}
//# sourceMappingURL=enhanced-sub-agent-handler.js.map