dev3000 0.0.75 → 0.0.77

package/mcp-server/app/mcp/tools.ts

@@ -19,7 +19,10 @@ export const TOOL_DESCRIPTIONS = {
     "🌐 **INTELLIGENT BROWSER AUTOMATION** - Smart browser action routing that automatically delegates to chrome-devtools MCP when available for superior automation capabilities.\n\n🎯 **INTELLIGENT DELEGATION:**\n• Screenshots → chrome-devtools MCP (better quality, no conflicts)\n• Navigation → chrome-devtools MCP (more reliable page handling)\n• Clicks → chrome-devtools MCP (precise coordinate-based interaction)\n• JavaScript evaluation → chrome-devtools MCP (enhanced debugging)\n• Scrolling & typing → dev3000 fallback (specialized actions)\n\n⚡ **PROGRESSIVE ENHANCEMENT:**\n• Uses chrome-devtools MCP when available for best results\n• Falls back to dev3000's native implementation when chrome-devtools unavailable\n• Shares the same Chrome instance via CDP URL coordination\n• Eliminates browser conflicts between tools\n\n💡 **PERFECT FOR:** Browser automation that automatically chooses the best tool for each action, ensuring optimal results whether chrome-devtools MCP is available or not.",
 
   discover_available_mcps:
-    "🔍 **PROACTIVE MCP DISCOVERY** - Automatically discover other MCPs running on the system using process detection and port pinging. No need to manually specify which MCPs are available!\n\n🎯 **DISCOVERY METHODS:**\n• Process Detection: Scans running processes for known MCP patterns\n• Port Pinging: Tests standard MCP ports with HTTP/WebSocket health checks\n• Cross-Platform: Works on macOS, Linux, and Windows\n\n⚡ **SMART DETECTION:**\n• Detects nextjs-dev, chrome-devtools, and other common MCPs\n• Fallback from process detection to port pinging\n• Logs all discovery attempts for transparency\n\n💡 **PERFECT FOR:** 'What MCPs are available?' or when you want dev3000 to automatically find and integrate with other debugging tools!"
+    "🔍 **PROACTIVE MCP DISCOVERY** - Automatically discover other MCPs running on the system using process detection and port pinging. No need to manually specify which MCPs are available!\n\n🎯 **DISCOVERY METHODS:**\n• Process Detection: Scans running processes for known MCP patterns\n• Port Pinging: Tests standard MCP ports with HTTP/WebSocket health checks\n• Cross-Platform: Works on macOS, Linux, and Windows\n\n⚡ **SMART DETECTION:**\n• Detects nextjs-dev, chrome-devtools, and other common MCPs\n• Fallback from process detection to port pinging\n• Logs all discovery attempts for transparency\n\n💡 **PERFECT FOR:** 'What MCPs are available?' or when you want dev3000 to automatically find and integrate with other debugging tools!",
+
+  get_mcp_capabilities:
+    "🔍 **MCP CAPABILITY INSPECTOR** - Discover and inspect the current capabilities of available MCPs (dev3000-chrome-devtools and dev3000-nextjs-dev). Shows dynamically discovered functions with descriptions and categories. Perfect for understanding what enhanced capabilities are available for augmented delegation.\n\n⚡ **DYNAMIC DISCOVERY:**\n• Introspects MCP logs and schemas to find available functions\n• Categorizes capabilities as 'advanced' vs 'basic'\n• Generates intelligent descriptions based on function names\n• Caches results for performance (5min TTL)\n\n🎯 **REAL-TIME UPDATES:**\n• Automatically adapts when MCPs add new capabilities\n• No manual maintenance required\n• Always shows current state of available tools\n\n💡 **PERFECT FOR:** Understanding what enhanced capabilities are currently available, debugging MCP integration issues, or planning augmented debugging workflows."
 }
 
 // Types
@@ -54,6 +57,10 @@ export interface ExecuteBrowserActionParams {
   params?: Record<string, unknown>
 }
 
+export interface GetMcpCapabilitiesParams {
+  mcpName?: string // Optional - if not provided, shows all available MCPs
+}
+
 // Structured data types for raw data output
 export interface ErrorWithInteractions {
   timestamp: string
@@ -531,7 +538,7 @@ export async function fixMyApp({
         if (integrateNextjs) {
           results.push("")
           results.push("⚛️ **Next.js Integration Active:**")
-          const nextjsSuggestions = generateNextjsSuggestions(allErrors.join(" "))
+          const nextjsSuggestions = await generateNextjsSuggestions(allErrors.join(" "))
           nextjsSuggestions.forEach((suggestion) => {
             const params = suggestion.params
               ? `(${Object.entries(suggestion.params)
@@ -552,7 +559,7 @@ export async function fixMyApp({
         if (integrateChromeDevtools) {
           results.push("")
           results.push("🌐 **Chrome DevTools Integration Active:**")
-          const chromeSuggestions = generateChromeDevtoolsSuggestions(allErrors.join(" "))
+          const chromeSuggestions = await generateChromeDevtoolsSuggestions(allErrors.join(" "))
           chromeSuggestions.forEach((suggestion) => {
             const params = suggestion.params
               ? `(${Object.entries(suggestion.params)
@@ -729,11 +736,11 @@ const value = data?.property?.nestedProperty`,
       const suggestedIntegrations: StructuredAnalysisResult["suggestedIntegrations"] = {}
 
       if (integrateNextjs) {
-        suggestedIntegrations.nextjs = generateNextjsSuggestions(allErrors.join(" "))
+        suggestedIntegrations.nextjs = await generateNextjsSuggestions(allErrors.join(" "))
       }
 
       if (integrateChromeDevtools) {
-        suggestedIntegrations.chrome = generateChromeDevtoolsSuggestions(allErrors.join(" "))
+        suggestedIntegrations.chrome = await generateChromeDevtoolsSuggestions(allErrors.join(" "))
       }
 
       // Create workflow plan if integrations are available
@@ -834,13 +841,37 @@ const value = data?.property?.nestedProperty`,
       }
     }
 
-    // Add nextjs-dev delegation recommendation if available
-    if (canDelegateNextjs) {
+    // Add augmented analysis suggestions when specialized MCPs are available
+    const canDelegateChrome = await canDelegateToChromeDevtools("profile_performance")
+
+    if (canDelegateNextjs || canDelegateChrome) {
       results.push("")
-      results.push("🔗 **ENHANCED NEXT.JS ANALYSIS AVAILABLE**")
+      results.push("🔗 **AUGMENTED ANALYSIS AVAILABLE**")
       results.push("")
-      const delegationResponse = await delegateToNextjs()
-      results.push(delegationResponse.content[0].text)
+      results.push("dev3000 provided the core log analysis above. For deeper insights, consider also gathering:")
+      results.push("")
+
+      if (canDelegateNextjs) {
+        results.push("**Next.js Framework Analysis:**")
+        const dynamicNextjsSuggestions = await generateNextjsSuggestions(allErrors.join(" "))
+        dynamicNextjsSuggestions.slice(0, 3).forEach((suggestion) => {
+          results.push(`• \`dev3000-nextjs-dev:${suggestion.function}()\` - ${suggestion.reason}`)
+        })
+        results.push("")
+      }
+
+      if (canDelegateChrome) {
+        results.push("**Browser-Side Analysis:**")
+        const dynamicChromeSuggestions = await generateChromeDevtoolsSuggestions(allErrors.join(" "))
+        dynamicChromeSuggestions.slice(0, 3).forEach((suggestion) => {
+          results.push(`• \`dev3000-chrome-devtools:${suggestion.function}()\` - ${suggestion.reason}`)
+        })
+        results.push("")
+      }
+
+      results.push(
+        "💡 **Best approach:** Use dev3000's log analysis as your foundation, then gather specific additional data as needed for a complete picture."
+      )
     }
 
     return {
@@ -858,73 +889,377 @@ const value = data?.property?.nestedProperty`,
   }
 }
 
-// Capability mapping between dev3000 and chrome-devtools MCP
-const CHROME_DEVTOOLS_CAPABILITY_MAP: Record<
-  string,
-  { function: string; paramMap?: (params: Record<string, unknown>) => Record<string, unknown> }
-> = {
-  screenshot: {
-    function: "take_screenshot",
-    paramMap: () => ({}) // chrome-devtools doesn't need params for screenshots
-  },
-  navigate: {
-    function: "navigate_page",
-    paramMap: (params) => ({ url: params.url })
-  },
-  click: {
-    function: "click",
-    paramMap: (params) => ({ x: params.x, y: params.y })
-  },
-  evaluate: {
-    function: "execute_script", // Assuming chrome-devtools has this
-    paramMap: (params) => ({ script: params.expression })
+// Dynamic MCP capability discovery and filtering
+interface McpCapability {
+  function: string
+  description?: string
+  parameters?: Record<string, unknown>
+  category: "advanced" | "basic"
+  reason: string
+}
+
+interface McpSchemaCache {
+  timestamp: number
+  capabilities: McpCapability[]
+}
+
+// Cache for discovered MCP capabilities (5 minute TTL)
+const MCP_CAPABILITY_CACHE = new Map<string, McpSchemaCache>()
+const CAPABILITY_CACHE_TTL = 5 * 60 * 1000 // 5 minutes
+
+// Keywords that indicate advanced capabilities (vs basic automation)
+const ADVANCED_CAPABILITY_KEYWORDS = {
+  chrome: [
+    "inspect",
+    "debug",
+    "profile",
+    "performance",
+    "console",
+    "devtools",
+    "breakpoint",
+    "intercept",
+    "storage",
+    "memory",
+    "trace"
+  ],
+  nextjs: ["build", "hydration", "ssr", "routing", "analyze", "debug", "render", "middleware", "optimization"]
+}
+
+// Basic capabilities that dev3000 handles well (should not suggest these)
+const DEV3000_BASIC_CAPABILITIES = [
+  "screenshot",
+  "navigate",
+  "click",
+  "type",
+  "scroll",
+  "evaluate",
+  "simple_script",
+  "get_logs",
+  "basic_build_status",
+  "simple_error_check"
+]
+
+/**
+ * Dynamically discover MCP capabilities by introspecting their schemas
+ */
+async function discoverMcpCapabilities(mcpName: string): Promise<McpCapability[]> {
+  const cacheKey = mcpName
+  const cached = MCP_CAPABILITY_CACHE.get(cacheKey)
+
+  // Return cached capabilities if still fresh
+  if (cached && Date.now() - cached.timestamp < CAPABILITY_CACHE_TTL) {
+    logToDevFile(
+      `Capability Discovery: Using cached capabilities for ${mcpName} (${cached.capabilities.length} functions)`
+    )
+    return cached.capabilities
+  }
+
+  logToDevFile(`Capability Discovery: Fetching fresh capabilities for ${mcpName}`)
+
+  try {
+    // Method 1: Try to get MCP schema via tools/list request (MCP protocol standard)
+    const capabilities = await introspectMcpTools(mcpName)
+
+    if (capabilities.length > 0) {
+      // Cache the results
+      MCP_CAPABILITY_CACHE.set(cacheKey, {
+        timestamp: Date.now(),
+        capabilities
+      })
+
+      logToDevFile(`Capability Discovery: Successfully discovered ${capabilities.length} capabilities for ${mcpName}`)
+      return capabilities
+    }
+
+    // Method 2: Fallback to checking available function names from logs/errors
+    const fallbackCapabilities = await inferCapabilitiesFromLogs(mcpName)
+
+    // Cache even fallback results to avoid repeated failures
+    MCP_CAPABILITY_CACHE.set(cacheKey, {
+      timestamp: Date.now(),
+      capabilities: fallbackCapabilities
+    })
+
+    logToDevFile(
+      `Capability Discovery: Using fallback inference for ${mcpName} (${fallbackCapabilities.length} functions)`
+    )
+    return fallbackCapabilities
+  } catch (error) {
+    logToDevFile(`Capability Discovery: Failed to discover capabilities for ${mcpName} - ${error}`)
+    return []
   }
-  // scroll and type don't have direct chrome-devtools equivalents, fall back to dev3000
 }
 
-// Capability mapping for nextjs-dev MCP delegation
-const NEXTJS_DEV_CAPABILITY_MAP: Record<string, { function: string; reason: string }> = {
-  get_build_status: {
-    function: "get_build_status",
-    reason: "Get comprehensive Next.js build information and status"
-  },
-  get_server_logs: {
-    function: "get_server_logs",
-    reason: "Access Next.js server-side logs and runtime information"
-  },
-  analyze_performance: {
-    function: "analyze_performance",
-    reason: "Get Next.js-specific performance metrics and optimization suggestions"
-  },
-  check_routes: {
-    function: "check_routes",
-    reason: "Validate Next.js routing configuration and detect issues"
+/**
+ * Introspect MCP tools using the standard tools/list request
+ */
+async function introspectMcpTools(mcpName: string): Promise<McpCapability[]> {
+  // For stdio MCPs, we can try to discover their capabilities by checking Claude's cache directory
+  // which often contains MCP schema information or error logs that reveal function names
+
+  try {
+    const cacheDir = `/Users/${process.env.USER}/Library/Caches/claude-cli-nodejs`
+    const { readdirSync, existsSync, readFileSync } = await import("fs")
+
+    if (!existsSync(cacheDir)) return []
+
+    const cacheDirs = readdirSync(cacheDir)
+    const projectDir = cacheDirs.find((dir) => dir.includes(process.cwd().replace(/\//g, "-")))
+
+    if (!projectDir) return []
+
+    const mcpLogDir = `${cacheDir}/${projectDir}/mcp-logs-${mcpName}`
+    if (!existsSync(mcpLogDir)) return []
+
+    // Look for schema information in MCP logs
+    const logFiles = readdirSync(mcpLogDir)
+    const capabilities: McpCapability[] = []
+
+    for (const logFile of logFiles.slice(-5)) {
+      // Check recent logs only
+      try {
+        const logPath = `${mcpLogDir}/${logFile}`
+        const logContent = readFileSync(logPath, "utf8")
+
+        // Parse log content for function definitions, tool lists, or schema information
+        const discoveredFunctions = extractFunctionsFromLog(logContent, mcpName)
+        capabilities.push(...discoveredFunctions)
+      } catch (_error) {
+        // Skip files that can't be read
+      }
+    }
+
+    return deduplicateCapabilities(capabilities)
+  } catch (error) {
+    logToDevFile(`MCP Introspection: Failed to introspect ${mcpName} - ${error}`)
+    return []
   }
 }
 
 /**
- * Check if chrome-devtools MCP is available and can handle the requested action
+ * Extract function names and descriptions from MCP log content
  */
-async function canDelegateToChromeDevtools(action: string): Promise<boolean> {
-  // First check if the action is mappable to chrome-devtools
-  if (!CHROME_DEVTOOLS_CAPABILITY_MAP[action]) {
-    return false
+function extractFunctionsFromLog(logContent: string, mcpName: string): McpCapability[] {
+  const capabilities: McpCapability[] = []
+  const mcpType: "chrome" | "nextjs" = mcpName.includes("chrome")
+    ? "chrome"
+    : mcpName.includes("nextjs")
+      ? "nextjs"
+      : "chrome" // default to chrome if unknown
+  const advancedKeywords = ADVANCED_CAPABILITY_KEYWORDS[mcpType]
+
+  // Look for function definitions in various formats
+  const patterns = [
+    // JSON-RPC method calls: {"method": "tools/list", "result": {"tools": [{"name": "function_name", "description": "..."}]}}
+    /"name":\s*"([^"]+)"/g,
+    // Function call patterns: functionName(params)
+    /(\w+)\s*\([^)]*\)/g,
+    // Tool definition patterns: tool: function_name
+    /tool:\s*(\w+)/g,
+    // Error messages that reveal function names: "Unknown function: function_name"
+    /unknown function[:\s]+(\w+)/gi,
+    // Function export patterns: exports.function_name
+    /exports\.(\w+)/g
+  ]
+
+  for (const pattern of patterns) {
+    let match: RegExpExecArray | null = pattern.exec(logContent)
+    while (match !== null) {
+      const functionName = match[1]
+
+      // Skip if this is a basic capability that dev3000 handles
+      if (DEV3000_BASIC_CAPABILITIES.some((basic) => functionName.toLowerCase().includes(basic))) {
+        match = pattern.exec(logContent)
+        continue
+      }
+
+      // Determine if this is an advanced capability
+      const isAdvanced = advancedKeywords.some((keyword) => functionName.toLowerCase().includes(keyword))
+
+      // Generate reason based on function name and MCP type
+      const reason = generateCapabilityReason(functionName, mcpType, isAdvanced)
+
+      capabilities.push({
+        function: functionName,
+        description: undefined, // Will be filled from actual description if available
+        category: isAdvanced ? "advanced" : "basic",
+        reason
+      })
+
+      match = pattern.exec(logContent)
+    }
+  }
+
+  return capabilities
+}
+
+/**
+ * Generate intelligent reason text for a discovered capability
+ */
+function generateCapabilityReason(functionName: string, mcpType: string, isAdvanced: boolean): string {
+  const name = functionName.toLowerCase()
+
+  // Chrome DevTools specific reasons
+  if (mcpType === "chrome") {
+    if (name.includes("inspect")) return "Deep DOM inspection with DevTools-level detail"
+    if (name.includes("console")) return "Direct browser console access and manipulation"
+    if (name.includes("debug") || name.includes("breakpoint"))
+      return "JavaScript debugging with breakpoints and call stack"
+    if (name.includes("profile") || name.includes("performance")) return "Advanced performance profiling and analysis"
+    if (name.includes("network") || name.includes("request")) return "Network request interception and analysis"
+    if (name.includes("storage")) return "Browser storage manipulation (cookies, localStorage, etc.)"
+    if (name.includes("trace") || name.includes("memory")) return "Memory usage and execution tracing"
+  }
+
+  // Next.js specific reasons
+  if (mcpType === "nextjs") {
+    if (name.includes("build")) return "Advanced Next.js build system analysis"
+    if (name.includes("hydration")) return "Client-server hydration debugging and analysis"
+    if (name.includes("ssr") || name.includes("render")) return "Server-side rendering debugging"
+    if (name.includes("route") || name.includes("routing")) return "Next.js routing system inspection and debugging"
+    if (name.includes("middleware")) return "Next.js middleware analysis and debugging"
+    if (name.includes("optimization") || name.includes("performance"))
+      return "Next.js-specific performance optimization"
+  }
+
+  // Generic advanced vs basic
+  if (isAdvanced) {
+    return `Advanced ${mcpType} capability beyond dev3000's basic automation`
+  }
+
+  return `${mcpType} capability for specialized analysis`
+}
+
+/**
+ * Infer capabilities from error patterns and log analysis when direct introspection fails
+ */
+async function inferCapabilitiesFromLogs(mcpName: string): Promise<McpCapability[]> {
+  // This is a fallback when we can't directly introspect the MCP
+  // We'll return commonly expected capabilities based on the MCP type
+
+  const mcpType = mcpName.includes("chrome") ? "chrome" : mcpName.includes("nextjs") ? "nextjs" : "unknown"
+  const capabilities: McpCapability[] = []
+
+  if (mcpType === "chrome") {
+    // Common chrome-devtools capabilities that are likely to exist
+    const commonChromeFunctions = [
+      "inspect_element",
+      "access_console",
+      "start_performance_profile",
+      "intercept_requests",
+      "set_breakpoint",
+      "take_screenshot",
+      "get_dom_snapshot",
+      "modify_storage",
+      "execute_script"
+    ]
+
+    for (const func of commonChromeFunctions) {
+      capabilities.push({
+        function: func,
+        category: DEV3000_BASIC_CAPABILITIES.includes(func) ? "basic" : "advanced",
+        reason: generateCapabilityReason(func, mcpType, true)
+      })
+    }
+  }
+
+  if (mcpType === "nextjs") {
+    // Common nextjs-dev capabilities that are likely to exist
+    const commonNextjsFunctions = [
+      "analyze_build_process",
+      "debug_server_rendering",
+      "debug_hydration",
+      "inspect_routing",
+      "analyze_next_performance",
+      "get_build_info",
+      "check_build_status",
+      "get_server_logs"
+    ]
+
+    for (const func of commonNextjsFunctions) {
+      capabilities.push({
+        function: func,
+        category: DEV3000_BASIC_CAPABILITIES.includes(func) ? "basic" : "advanced",
+        reason: generateCapabilityReason(func, mcpType, true)
+      })
+    }
+  }
+
+  logToDevFile(`Capability Inference: Generated ${capabilities.length} inferred capabilities for ${mcpName}`)
+  return capabilities
+}
+
+/**
+ * Remove duplicate capabilities while preserving the most detailed ones
+ */
+function deduplicateCapabilities(capabilities: McpCapability[]): McpCapability[] {
+  const seen = new Map<string, McpCapability>()
+
+  for (const capability of capabilities) {
+    const existing = seen.get(capability.function)
+
+    // Keep the one with more information (description, better reason, etc.)
+    if (
+      !existing ||
+      (capability.description && !existing.description) ||
+      capability.reason.length > existing.reason.length
+    ) {
+      seen.set(capability.function, capability)
+    }
   }
 
-  // dev3000 cannot reliably detect its own configured MCPs in Claude Code
-  // Return false to disable auto-delegation - users can manually use the MCPs
-  logToDevFile(`Chrome DevTools delegation disabled - cannot verify dev3000-chrome-devtools MCP configuration`)
-  return false
+  return Array.from(seen.values())
+}
+
+/**
+ * Check if chrome-devtools MCP is available and get its capabilities
+ */
+async function canDelegateToChromeDevtools(action?: string): Promise<boolean> {
+  try {
+    // Check if MCP is available
+    const availableMcps = await discoverAvailableMcps()
+    if (!availableMcps.includes("dev3000-chrome-devtools")) {
+      return false
+    }
+
+    // If no specific action, just return availability
+    if (!action) return true
+
+    // Get dynamic capabilities
+    const capabilities = await discoverMcpCapabilities("dev3000-chrome-devtools")
+
+    // Check if the MCP has relevant capabilities for the action
+    const hasRelevantCapability = capabilities.some(
+      (cap) => cap.function.toLowerCase().includes(action.toLowerCase()) || cap.category === "advanced" // Any advanced capability indicates delegation worthiness
+    )
+
+    return hasRelevantCapability
+  } catch (error) {
+    logToDevFile(`Chrome DevTools delegation check failed: ${error}`)
+    return false
+  }
 }
 
 /**
- * Check if nextjs-dev MCP is available
+ * Check if nextjs-dev MCP is available and get its capabilities
  */
 async function canDelegateToNextjs(): Promise<boolean> {
-  // dev3000 cannot reliably detect its own configured MCPs in Claude Code
-  // Return false to disable auto-delegation - users can manually use the MCPs
-  logToDevFile(`NextJS delegation disabled - cannot verify dev3000-nextjs-dev MCP configuration`)
-  return false
+  try {
+    // Check if MCP is available
+    const availableMcps = await discoverAvailableMcps()
+    if (!availableMcps.includes("dev3000-nextjs-dev")) {
+      return false
+    }
+
+    // Get dynamic capabilities to verify it has useful functions
+    const capabilities = await discoverMcpCapabilities("dev3000-nextjs-dev")
+
+    // Return true if we found any advanced Next.js capabilities
+    return capabilities.some((cap) => cap.category === "advanced")
+  } catch (error) {
+    logToDevFile(`NextJS delegation check failed: ${error}`)
+    return false
+  }
 }
 
 /**
@@ -934,32 +1269,39 @@ async function delegateToChromeDevtools(
   action: string,
   params: Record<string, unknown>
 ): Promise<{ content: Array<{ type: "text"; text: string }> }> {
-  const mapping = CHROME_DEVTOOLS_CAPABILITY_MAP[action]
-  if (!mapping) {
+  // Get dynamic capabilities from chrome-devtools MCP
+  const capabilities = await discoverMcpCapabilities("dev3000-chrome-devtools")
+
+  // Find a relevant capability for this action
+  const relevantCap = capabilities.find(
+    (cap) =>
+      cap.function.toLowerCase().includes(action.toLowerCase()) ||
+      cap.description?.toLowerCase().includes(action.toLowerCase())
+  )
+
+  if (!relevantCap) {
     throw new Error(`Action ${action} cannot be delegated to chrome-devtools`)
   }
 
-  // Transform parameters if needed
-  const chromeParams = mapping.paramMap ? mapping.paramMap(params) : params
-
   return {
     content: [
       {
         type: "text",
-        text: `🔗 **USE DEV3000-CHROME-DEVTOOLS MCP**
+        text: `🔗 **ADVANCED BROWSER DEBUGGING AVAILABLE**
 
-If you have chrome-devtools MCP configured, please use the \`dev3000-chrome-devtools\` MCP directly:
+For advanced debugging capabilities, use the \`dev3000-chrome-devtools\` MCP:
 
 \`\`\`
-dev3000-chrome-devtools:${mapping.function}(${JSON.stringify(chromeParams, null, 2)})
+dev3000-chrome-devtools:${relevantCap.function}(${JSON.stringify(params, null, 2)})
 \`\`\`
 
-💡 **If the MCP is not available:**
-• Make sure chrome-devtools MCP is configured in your Claude Code client
-• Claude Code should auto-configure it as \`dev3000-chrome-devtools\`
-• Alternatively, dev3000 will fallback to its basic browser automation
+🎯 **Why use chrome-devtools for this:** ${relevantCap.reason}
 
-⚡ **Note:** dev3000 detected chrome-devtools activity but cannot verify MCP configuration`
+💡 **When to use each tool:**
+• **dev3000**: Basic browser automation (screenshots, navigation, clicks, simple scripts)
+• **dev3000-chrome-devtools**: Advanced debugging (DOM inspection, breakpoints, performance profiling, network interception)
+
+⚡ **Both tools share the same Chrome instance** - no conflicts or duplicate browsers`
       }
     ]
   }
@@ -968,28 +1310,30 @@ dev3000-chrome-devtools:${mapping.function}(${JSON.stringify(chromeParams, null,
 /**
  * Delegate to nextjs-dev MCP with suggested functions
  */
-async function delegateToNextjs(): Promise<{ content: Array<{ type: "text"; text: string }> }> {
-  const availableFunctions = Object.entries(NEXTJS_DEV_CAPABILITY_MAP)
-    .map(([_key, { function: func, reason }]) => `• \`dev3000-nextjs-dev:${func}()\` - ${reason}`)
+async function _delegateToNextjs(): Promise<{ content: Array<{ type: "text"; text: string }> }> {
+  // Get dynamic capabilities from nextjs-dev MCP
+  const capabilities = await discoverMcpCapabilities("dev3000-nextjs-dev")
+
+  const availableFunctions = capabilities
+    .map((cap) => `• \`dev3000-nextjs-dev:${cap.function}()\` - ${cap.reason}`)
     .join("\n")
 
   return {
     content: [
       {
         type: "text",
-        text: `🔗 **USE DEV3000-NEXTJS-DEV MCP**
+        text: `🔗 **ADVANCED NEXT.JS ANALYSIS AVAILABLE**
 
-Please use the \`dev3000-nextjs-dev\` MCP directly for Next.js-specific analysis:
+For Next.js-specific advanced analysis, use the \`dev3000-nextjs-dev\` MCP:
 
-**Available Functions:**
+**Available Advanced Functions:**
 ${availableFunctions}
 
-💡 **Why this approach:**
-• nextjs-dev is a stdio MCP server that Claude calls directly
-• Provides Next.js-specific build, server, and performance insights
-• Direct MCP calls give better framework-specific context
+💡 **When to use each tool:**
+• **dev3000**: General log analysis, basic error detection, simple build monitoring
+• **dev3000-nextjs-dev**: Advanced Next.js debugging (SSR issues, hydration problems, build system analysis, routing inspection)
 
-⚡ **Auto-configured as:** \`dev3000-nextjs-dev\` in your MCP client`
+⚡ **Best of both worlds:** Use dev3000 for general monitoring and nextjs-dev for framework-specific deep dives`
       }
     ]
   }
@@ -1244,11 +1588,46 @@ export async function executeBrowserAction({
       ws.on("error", reject)
     })
 
+    // Build success message with augmented suggestions
+    let successMessage = `Browser action '${action}' executed successfully. Result: ${JSON.stringify(result, null, 2)}`
+
+    // Add augmented suggestions for enhanced capabilities
+    const canDelegateChrome = await canDelegateToChromeDevtools("inspect_element")
+    if (canDelegateChrome) {
+      successMessage += "\n\n🔗 **ENHANCED BROWSER ANALYSIS AVAILABLE**"
+      successMessage +=
+        "\n\ndev3000 completed the basic browser action above. For deeper browser insights, consider also:"
+
+      // Generate dynamic suggestions based on the action and available capabilities
+      const dynamicSuggestions = await generateChromeDevtoolsSuggestions(action)
+      const actionRelevantSuggestions = dynamicSuggestions.filter((suggestion) => {
+        const funcName = suggestion.function.toLowerCase()
+        const actionName = action.toLowerCase()
+
+        // Match suggestions to specific actions
+        if (actionName === "screenshot" && (funcName.includes("inspect") || funcName.includes("performance")))
+          return true
+        if (actionName === "evaluate" && (funcName.includes("console") || funcName.includes("inspect"))) return true
+        if (actionName === "navigate" && (funcName.includes("network") || funcName.includes("performance"))) return true
+        if (actionName === "click" && (funcName.includes("console") || funcName.includes("inspect"))) return true
+
+        // Include high-priority suggestions regardless
+        return suggestion.priority === "high"
+      })
+
+      actionRelevantSuggestions.slice(0, 2).forEach((suggestion) => {
+        successMessage += `\n• \`dev3000-chrome-devtools:${suggestion.function}()\` - ${suggestion.reason}`
+      })
+
+      successMessage +=
+        "\n\n💡 **Augmented approach:** Use dev3000 for basic automation, chrome-devtools for detailed analysis and debugging."
+    }
+
     return {
       content: [
         {
           type: "text",
-          text: `Browser action '${action}' executed successfully. Result: ${JSON.stringify(result, null, 2)}`
+          text: successMessage
         }
       ]
     }
@@ -1402,9 +1781,47 @@ export async function discoverAvailableMcps(projectName?: string): Promise<strin
     discoveredMcps.add(mcp)
   }
 
-  // Method 2: Port pinging (only if process detection found nothing)
+  // Method 2: Check for dev3000-configured MCPs by testing their functionality
+  try {
+    // Test if dev3000-chrome-devtools MCP is working by checking Claude logs
+    const cacheDir = `/Users/${process.env.USER}/Library/Caches/claude-cli-nodejs`
+    const { readdirSync, existsSync } = await import("fs")
+
+    if (existsSync(cacheDir)) {
+      const cacheDirs = readdirSync(cacheDir)
+      const projectDir = cacheDirs.find((dir) => dir.includes(process.cwd().replace(/\//g, "-")))
+
+      if (projectDir) {
+        const projectCacheDir = `${cacheDir}/${projectDir}`
+
+        // Check for chrome-devtools MCP logs
+        const chromeDevtoolsLogDir = `${projectCacheDir}/mcp-logs-dev3000-chrome-devtools`
+        if (existsSync(chromeDevtoolsLogDir)) {
+          const chromeDevtoolsLogs = readdirSync(chromeDevtoolsLogDir)
+          if (chromeDevtoolsLogs.length > 0) {
+            discoveredMcps.add("dev3000-chrome-devtools")
+            logToDevFile("MCP Discovery: Found dev3000-chrome-devtools via Claude cache logs", projectName)
+          }
+        }
+
+        // Check for nextjs-dev MCP logs
+        const nextjsDevLogDir = `${projectCacheDir}/mcp-logs-dev3000-nextjs-dev`
+        if (existsSync(nextjsDevLogDir)) {
+          const nextjsDevLogs = readdirSync(nextjsDevLogDir)
+          if (nextjsDevLogs.length > 0) {
+            discoveredMcps.add("dev3000-nextjs-dev")
+            logToDevFile("MCP Discovery: Found dev3000-nextjs-dev via Claude cache logs", projectName)
+          }
+        }
+      }
+    }
+  } catch (_error) {
+    logToDevFile("MCP Discovery: Claude cache check failed, falling back to port detection", projectName)
+  }
+
+  // Method 3: Port pinging (fallback)
   if (discoveredMcps.size === 0) {
-    logToDevFile("MCP Discovery: No MCPs found via process detection, trying port pinging", projectName)
+    logToDevFile("MCP Discovery: No MCPs found via process or cache detection, trying port pinging", projectName)
     const portDetected = await pingMcpPorts()
     for (const mcp of portDetected) {
       discoveredMcps.add(mcp)
@@ -1422,6 +1839,140 @@ export async function discoverAvailableMcps(projectName?: string): Promise<strin
   return finalMcps
 }
 
+/**
+ * Get and display MCP capabilities for debugging and inspection
+ */
+export async function getMcpCapabilities({
+  mcpName
+}: GetMcpCapabilitiesParams = {}): Promise<{ content: Array<{ type: "text"; text: string }> }> {
+  const results: string[] = []
+
+  results.push("🔍 **MCP CAPABILITY INSPECTOR**")
+  results.push("")
+
+  try {
+    // Discover available MCPs if no specific one requested
+    const availableMcps = await discoverAvailableMcps()
+
+    if (availableMcps.length === 0) {
+      results.push("❌ **NO MCPs DETECTED**")
+      results.push("No dev3000-chrome-devtools or dev3000-nextjs-dev MCPs found.")
+      results.push("")
+      results.push("💡 **To enable enhanced capabilities:**")
+      results.push("• Ensure Chrome DevTools MCP is configured: `dev3000-chrome-devtools`")
+      results.push("• Ensure Next.js Dev MCP is configured: `dev3000-nextjs-dev`")
+      results.push("• Check that Claude Code has MCPs properly configured")
+
+      return {
+        content: [{ type: "text", text: results.join("\n") }]
+      }
+    }
+
+    results.push(`✅ **DISCOVERED MCPs:** ${availableMcps.join(", ")}`)
+    results.push("")
+
+    // Filter to specific MCP if requested
+    const mcpsToInspect = mcpName ? availableMcps.filter((name) => name.includes(mcpName)) : availableMcps
+
+    if (mcpsToInspect.length === 0 && mcpName) {
+      results.push(`❌ **MCP NOT FOUND:** ${mcpName}`)
+      results.push(`Available MCPs: ${availableMcps.join(", ")}`)
+
+      return {
+        content: [{ type: "text", text: results.join("\n") }]
+      }
+    }
+
+    // Inspect capabilities for each MCP
+    for (const mcp of mcpsToInspect) {
+      results.push(`📋 **${mcp.toUpperCase()} CAPABILITIES:**`)
+      results.push("")
+
+      const capabilities = await discoverMcpCapabilities(mcp)
+
+      if (capabilities.length === 0) {
+        results.push("  ❌ No capabilities discovered")
+        results.push("  💡 This might indicate the MCP is not properly configured or accessible")
+        results.push("")
+        continue
+      }
+
+      // Group by category
+      const advanced = capabilities.filter((cap) => cap.category === "advanced")
+      const basic = capabilities.filter((cap) => cap.category === "basic")
+
+      results.push(`  🚀 **ADVANCED CAPABILITIES** (${advanced.length} functions):`)
+      if (advanced.length > 0) {
+        advanced.forEach((cap) => {
+          results.push(`    • \`${cap.function}()\` - ${cap.reason}`)
+        })
+      } else {
+        results.push("    No advanced capabilities discovered")
+      }
+      results.push("")
+
+      results.push(`  ⚙️ **BASIC CAPABILITIES** (${basic.length} functions):`)
+      if (basic.length > 0) {
+        basic.forEach((cap) => {
+          results.push(`    • \`${cap.function}()\` - ${cap.reason}`)
+        })
+      } else {
+        results.push("    No basic capabilities discovered")
+      }
+      results.push("")
+
+      // Cache info
+      const cached = MCP_CAPABILITY_CACHE.get(mcp)
+      if (cached) {
+        const age = Date.now() - cached.timestamp
+        const ageMinutes = Math.floor(age / 60000)
+        results.push(`  📝 **CACHE INFO:** Discovered ${ageMinutes} minutes ago`)
+        if (age > CAPABILITY_CACHE_TTL * 0.8) {
+          results.push("  ⚠️  Cache will refresh soon on next use")
+        }
+      }
+      results.push("")
+    }
+
+    // Summary
+    const totalCapabilities = mcpsToInspect.reduce(async (accPromise, mcp) => {
+      const acc = await accPromise
+      const caps = await discoverMcpCapabilities(mcp)
+      return acc + caps.length
+    }, Promise.resolve(0))
+
+    results.push("🎯 **AUGMENTED DELEGATION STATUS:**")
+    results.push(`• Total discovered capabilities: ${await totalCapabilities}`)
+    results.push(
+      `• MCPs with advanced capabilities: ${
+        mcpsToInspect.filter(async (mcp) => {
+          const caps = await discoverMcpCapabilities(mcp)
+          return caps.some((cap) => cap.category === "advanced")
+        }).length
+      }`
+    )
+    results.push("• Dynamic discovery: ✅ Active (updates automatically)")
+    results.push("• Cache TTL: 5 minutes")
+    results.push("")
+    results.push("💡 **These capabilities are automatically suggested in dev3000's enhanced responses!**")
+
+    return {
+      content: [{ type: "text", text: results.join("\n") }]
+    }
+  } catch (error) {
+    results.push(`❌ **ERROR INSPECTING CAPABILITIES:** ${error instanceof Error ? error.message : String(error)}`)
+    results.push("")
+    results.push("💡 **Troubleshooting:**")
+    results.push("• Check that MCPs are properly configured in Claude Code")
+    results.push("• Verify dev3000 can access Claude cache directories")
+    results.push("• Try running `discover_available_mcps()` first")
+
+    return {
+      content: [{ type: "text", text: results.join("\n") }]
+    }
+  }
+}
+
 /**
  * Log MCP-related events to the project-specific D3K log file (NOT main project log)
  * This prevents Claude from seeing dev3000's orchestration logs as application errors
@@ -1524,85 +2075,119 @@ export function calculateEstimatedTime(errorCount: number, hasIntegrations: bool
 }
 
 /**
- * Generate Next.js specific MCP function suggestions
+ * Generate dynamic Next.js specific MCP function suggestions based on discovered capabilities
  */
-export function generateNextjsSuggestions(errorContext?: string): McpFunctionSuggestion[] {
-  const suggestions: McpFunctionSuggestion[] = [
-    {
-      function: "check_errors",
-      reason: "Analyze Next.js build and runtime errors with framework-specific context",
-      priority: "high"
-    },
-    {
-      function: "get_logs",
-      params: { type: "error", limit: 20 },
-      reason: "Retrieve detailed Next.js server logs to correlate with dev3000 findings",
-      priority: "high"
-    }
-  ]
+export async function generateNextjsSuggestions(errorContext?: string): Promise<McpFunctionSuggestion[]> {
+  try {
+    // Get dynamic capabilities from the MCP
+    const capabilities = await discoverMcpCapabilities("dev3000-nextjs-dev")
+
+    // Filter for advanced capabilities and create suggestions
+    const suggestions: McpFunctionSuggestion[] = capabilities
+      .filter((cap) => cap.category === "advanced")
+      .slice(0, 8) // Limit to most relevant suggestions
+      .map((cap) => ({
+        function: cap.function,
+        reason: cap.reason,
+        priority: determinePriority(cap.function, errorContext) as "high" | "medium" | "low"
+      }))
+
+    logToDevFile(
+      `Dynamic Suggestions: Generated ${suggestions.length} Next.js suggestions from ${capabilities.length} discovered capabilities`
+    )
 
-  // Add context-specific suggestions
-  if (errorContext?.includes("hydration")) {
-    suggestions.push({
-      function: "check_hydration_errors",
-      reason: "Specific hydration mismatch analysis detected in error context",
-      priority: "high"
-    })
-  }
+    return suggestions
+  } catch (error) {
+    logToDevFile(`Dynamic Suggestions: Failed to generate Next.js suggestions - ${error}`)
 
-  if (errorContext?.includes("build") || errorContext?.includes("compile")) {
-    suggestions.push({
-      function: "get_build_info",
-      reason: "Build-related errors detected, get detailed compilation information",
-      priority: "high"
-    })
+    // Fallback to basic suggestions if discovery fails
+    return [
+      {
+        function: "analyze_build_process",
+        reason: "Advanced Next.js build system analysis",
+        priority: "high"
+      },
+      {
+        function: "debug_server_rendering",
+        reason: "Server-side rendering debugging",
+        priority: "high"
+      }
+    ]
   }
+}
 
-  return suggestions
+/**
+ * Generate dynamic Chrome DevTools specific MCP function suggestions based on discovered capabilities
+ */
+export async function generateChromeDevtoolsSuggestions(errorContext?: string): Promise<McpFunctionSuggestion[]> {
+  try {
+    // Get dynamic capabilities from the MCP
+    const capabilities = await discoverMcpCapabilities("dev3000-chrome-devtools")
+
+    // Filter for advanced capabilities and create suggestions
+    const suggestions: McpFunctionSuggestion[] = capabilities
+      .filter((cap) => cap.category === "advanced")
+      .slice(0, 8) // Limit to most relevant suggestions
+      .map((cap) => ({
+        function: cap.function,
+        reason: cap.reason,
+        priority: determinePriority(cap.function, errorContext) as "high" | "medium" | "low"
+      }))
+
+    logToDevFile(
+      `Dynamic Suggestions: Generated ${suggestions.length} Chrome DevTools suggestions from ${capabilities.length} discovered capabilities`
+    )
+
+    return suggestions
+  } catch (error) {
+    logToDevFile(`Dynamic Suggestions: Failed to generate Chrome DevTools suggestions - ${error}`)
+
+    // Fallback to basic suggestions if discovery fails
+    return [
+      {
+        function: "inspect_element",
+        reason: "Deep DOM inspection with DevTools-level detail",
+        priority: "high"
+      },
+      {
+        function: "access_console",
+        reason: "Direct browser console access and manipulation",
+        priority: "high"
+      }
+    ]
+  }
 }
 
 /**
- * Generate Chrome DevTools specific MCP function suggestions
+ * Determine priority of a capability based on error context and function relevance
  */
-export function generateChromeDevtoolsSuggestions(errorContext?: string): McpFunctionSuggestion[] {
-  const suggestions: McpFunctionSuggestion[] = [
-    {
-      function: "list_console_messages",
-      params: { type: "error", limit: 20 },
-      reason: "Get detailed browser console errors to correlate with dev3000 interaction data",
-      priority: "high"
-    },
-    {
-      function: "list_network_requests",
-      params: { failed: true },
-      reason: "Analyze failed network requests that may be causing application errors",
-      priority: "medium"
-    },
-    {
-      function: "take_screenshot",
-      reason: "Capture current browser state for visual debugging",
-      priority: "low"
-    }
+function determinePriority(functionName: string, errorContext?: string): "high" | "medium" | "low" {
+  const name = functionName.toLowerCase()
+  const context = errorContext?.toLowerCase() || ""
+
+  // High priority matches - function directly relates to error context
+  const highPriorityPatterns = [
+    { pattern: /hydration/, keywords: ["hydration", "ssr", "render"] },
+    { pattern: /build|compile/, keywords: ["build", "compile", "analyze"] },
+    { pattern: /network|fetch|api/, keywords: ["network", "request", "intercept", "performance"] },
+    { pattern: /console|error/, keywords: ["console", "error", "debug"] },
+    { pattern: /click|interaction/, keywords: ["dom", "element", "inspect"] }
   ]
 
-  // Add context-specific suggestions
-  if (errorContext?.includes("network") || errorContext?.includes("fetch") || errorContext?.includes("api")) {
-    suggestions.push({
-      function: "get_performance_metrics",
-      reason: "Network-related errors detected, analyze performance and timing",
-      priority: "high"
-    })
+  for (const { pattern, keywords } of highPriorityPatterns) {
+    if (pattern.test(context) && keywords.some((keyword) => name.includes(keyword))) {
+      return "high"
+    }
   }
 
-  if (errorContext?.includes("click") || errorContext?.includes("interaction")) {
-    suggestions.push({
-      function: "get_dom_snapshot",
-      reason: "Interaction errors detected, capture DOM state for element analysis",
-      priority: "medium"
-    })
+  // Medium priority - advanced debugging capabilities
+  const mediumPriorityKeywords = ["debug", "profile", "analyze", "trace", "inspect"]
+  if (mediumPriorityKeywords.some((keyword) => name.includes(keyword))) {
+    return "medium"
   }
 
-  return suggestions
+  // Low priority - basic or less critical functions
+  return "low"
 }
 
 /**
@@ -1642,8 +2227,8 @@ export async function createIntegratedWorkflow({
   results.push("")
 
   // Generate MCP-specific suggestions
-  const nextjsSuggestions = integrateNextjs ? generateNextjsSuggestions(errorContext) : []
-  const chromeSuggestions = integrateChromeDevtools ? generateChromeDevtoolsSuggestions(errorContext) : []
+  const nextjsSuggestions = integrateNextjs ? await generateNextjsSuggestions(errorContext) : []
+  const chromeSuggestions = integrateChromeDevtools ? await generateChromeDevtoolsSuggestions(errorContext) : []
 
   if (!integrateNextjs && !integrateChromeDevtools) {
     results.push("⚠️ **NO INTEGRATIONS DETECTED**")