Add DAP (Debug Adapter Protocol) support — enable breakpoint debugging via plugin system

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

When debugging Dart/Flutter (or any language) code with Claude Code, I have to switch to VS Code or Android Studio to set
breakpoints, inspect variables, and step through code. Claude Code has excellent code intelligence via LSP but zero runtime
debugging capability. This breaks the flow — I describe a bug to Claude, it analyzes the code statically, but when we need
to verify runtime state, I have to leave Claude Code entirely, reproduce the issue in an IDE, copy the output back, and
continue the conversation. This back-and-forth is slow and loses context.

Proposed Solution

Add DAP (Debug Adapter Protocol) support to Claude Code's plugin system, following the same architecture as the existing
LSP plugin support.

DAP uses the exact same transport as LSP — subprocess + stdin/stdout + JSON-RPC — so the infrastructure already exists. A
.dap.json config (similar to .lsp.json) would let the community marketplace provide ready-made configs for any language:

{
"dart": {
"command": "dart",
"args": ["debug_adapter"],
"languages": ["dart"]
}
}

Exposed operations could include:

• dap_launch / dap_attach — start or connect to a process
• dap_setBreakpoints — set breakpoints by file and line
• dap_continue / dap_stepIn / dap_stepOver / dap_stepOut — control execution
• dap_evaluate — evaluate expressions in a paused context
• dap_stackTrace — get the current call stack
• dap_variables — inspect variable state at a breakpoint

This would let Claude Code set a breakpoint, run the app, hit the breakpoint, inspect state, and reason about the bug — all
without leaving the conversation.

Alternative Solutions

• Currently I switch to VS Code/Android Studio for debugging, then copy findings back to Claude Code. Works, but breaks

flow and loses conversational context.

• The Dart MCP server provides get_runtime_errors from a running app, which helps for crash-level issues but doesn't

support breakpoints or state inspection.

• LSP provides static analysis (hover, go-to-definition, find-references) which helps with code understanding but can't

observe runtime behavior.

Priority

High - Significant impact on productivity

Feature Category

Developer tools/SDK

Use Case Example

1. I'm working on a Flutter app with Riverpod state management
2. A controller isn't transitioning to the correct state after an async operation
3. I ask Claude Code to investigate — it uses LSP to trace the call chain and reads the code
4. Static analysis isn't enough — we need to see what value a variable holds at runtime
5. With DAP: Claude sets a breakpoint at the suspicious line, launches the app in debug mode, triggers the action, hits the

breakpoint, inspects the variable, and identifies the bug — all in one conversation

1. Without DAP: I switch to VS Code, set the breakpoint manually, reproduce the issue, read the debugger output, switch

back to Claude Code, and paste what I found. If Claude needs another breakpoint, I repeat the whole cycle

Additional Context

DAP servers already ship with most language toolchains:

┌──────────────┬────────────────────┬───────────────────┐
│ Language │ Command │ Ships with │
├──────────────┼────────────────────┼───────────────────┤
│ Dart/Flutter │ dart debug_adapter │ Dart SDK (source) │
├──────────────┼────────────────────┼───────────────────┤
│ Python │ debugpy │ pip install │
├──────────────┼────────────────────┼───────────────────┤
│ Node.js │ js-debug │ VS Code / npm │
├──────────────┼────────────────────┼───────────────────┤
│ Go │ dlv dap │ Delve │
├──────────────┼────────────────────┼───────────────────┤
│ C/C++ │ lldb-dap │ LLVM │
├──────────────┼────────────────────┼───────────────────┤
│ Rust │ codelldb │ VS Code extension │
└──────────────┴────────────────────┴───────────────────┘

The existing claude-code-lsps community marketplace could expand to claude-code-daps with the same pattern. This would make
Claude Code the first AI coding agent with native debugging capabilities.