Enable dynamic breakpoint setting during debugging

- Generate #line directives for ALL nodes in debug builds (not just breakpointed ones)
- All nodes now tracked in PDB with virtual line numbers
- Added ShouldSetBreakpointForNode delegate to filter which breakpoints to set
- Added SetBreakpointForNode/RemoveBreakpointForNode methods to Project
- Breakpoints can now be added/removed dynamically after build and attach
- All 9 unit tests passing

This allows users to add breakpoints at any time during a debug session, not just before building.

Co-authored-by: snakex64 <39806655+snakex64@users.noreply.github.com>

Author: Copilot

src/NodeDev.Core/CodeGeneration/RoslynGraphBuilder.cs

@@ -98,7 +98,9 @@ public MethodDeclarationSyntax BuildMethod()
 		// Get full class name for breakpoint info
 		string fullClassName = $"{_graph.SelfClass.Namespace}.{_graph.SelfClass.Name}";
 
-		var bodyStatements = _context.IsDebug && _graph.Nodes.Values.Any(n => n.HasBreakpoint)
+		// In debug builds, always track line numbers for all nodes (not just those with breakpoints)
+		// This allows breakpoints to be set dynamically during debugging
+		var bodyStatements = _context.IsDebug
 			? BuildStatementsWithBreakpointTracking(chunks, fullClassName, method.Name)
 			: BuildStatements(chunks);
 
@@ -204,39 +206,38 @@ internal List<StatementSyntax> BuildStatementsWithBreakpointTracking(Graph.NodeP
 				// Generate the statement for this node
 				var statement = node.GenerateRoslynStatement(chunk.SubChunk, _context);
 
-				// If this node has a breakpoint, add #line directive and record mapping
-				if (node.HasBreakpoint)
+				// In debug builds, ALWAYS add #line directive for every node (not just those with breakpoints)
+				// This allows breakpoints to be set dynamically during debugging
+				// Create a #line directive that maps this statement to a unique virtual line
+				// The virtual line encodes the node's execution order: 10000 + (order * 1000)
+				int nodeVirtualLine = 10000 + (nodeExecutionOrder * 1000);
+				
+				// Format: #line 10000 "virtual_file.cs"
+				var lineDirective = SF.Trivia(
+					SF.LineDirectiveTrivia(
+						SF.Token(SyntaxKind.HashToken),
+						SF.Token(SyntaxKind.LineKeyword),
+						SF.Literal(nodeVirtualLine),
+						SF.Literal($"\"{virtualFileName}\"", virtualFileName), // Quoted filename
+						SF.Token(SyntaxKind.EndOfDirectiveToken),
+						true
+					)
+				);
+				
+				// Add the #line directive before the statement
+				statement = statement.WithLeadingTrivia(lineDirective);
+				
+				// Record the mapping for this node (regardless of whether it currently has a breakpoint)
+				// This allows breakpoints to be added dynamically after build
+				_context.BreakpointMappings.Add(new NodeDev.Core.Debugger.NodeBreakpointInfo
 				{
-					// Create a #line directive that maps this statement to a unique virtual line
-					// The virtual line encodes the node's execution order: 10000 + (order * 1000)
-					int nodeVirtualLine = 10000 + (nodeExecutionOrder * 1000);
-					
-					// Format: #line 10000 "virtual_file.cs"
-					var lineDirective = SF.Trivia(
-						SF.LineDirectiveTrivia(
-							SF.Token(SyntaxKind.HashToken),
-							SF.Token(SyntaxKind.LineKeyword),
-							SF.Literal(nodeVirtualLine),
-							SF.Literal($"\"{virtualFileName}\"", virtualFileName), // Quoted filename
-							SF.Token(SyntaxKind.EndOfDirectiveToken),
-							true
-						)
-					);
-					
-					// Add the #line directive before the statement
-					statement = statement.WithLeadingTrivia(lineDirective);
-					
-					// Record the breakpoint mapping with the virtual line number
-					_context.BreakpointMappings.Add(new NodeDev.Core.Debugger.NodeBreakpointInfo
-					{
-						NodeId = node.Id,
-						NodeName = node.Name,
-						ClassName = className,
-						MethodName = methodName,
-						LineNumber = nodeVirtualLine,
-						SourceFile = virtualFileName
-					});
-				}
+					NodeId = node.Id,
+					NodeName = node.Name,
+					ClassName = className,
+					MethodName = methodName,
+					LineNumber = nodeVirtualLine,
+					SourceFile = virtualFileName
+				});
 
 				// Add the main statement
 				statements.Add(statement);

src/NodeDev.Core/Debugger/DebugSessionEngine.cs

@@ -27,6 +27,13 @@ public class DebugSessionEngine : IDisposable
 	/// Provides the NodeBreakpointInfo for the node where the breakpoint was hit.
 	/// </summary>
 	public event EventHandler<NodeBreakpointInfo>? BreakpointHit;
+	
+	/// <summary>
+	/// Delegate to check if a node should have a breakpoint set.
+	/// This is called during breakpoint setup to filter which nodes should have breakpoints.
+	/// Returns true if the node should have a breakpoint, false otherwise.
+	/// </summary>
+	public Func<string, bool>? ShouldSetBreakpointForNode { get; set; }
 
 	/// <summary>
 	/// Gets the current debug process, if any.
@@ -361,8 +368,11 @@ public void SetBreakpointMappings(BreakpointMappingInfo? mappings)
 	/// <summary>
 	/// Sets breakpoints in the debugged process based on the breakpoint mappings.
 	/// This should be called after modules are loaded (typically in LoadModule callback).
+	/// In the new design, this method is called during module load but only sets breakpoints
+	/// for nodes that currently have HasBreakpoint set to true (checked via ShouldSetBreakpointForNode delegate).
 	/// </summary>
-	public void TrySetBreakpointsForLoadedModules()
+	/// <param name="nodeFilter">Optional filter to only set breakpoints for specific node IDs. If null, processes all nodes with breakpoints.</param>
+	public void TrySetBreakpointsForLoadedModules(Func<NodeBreakpointInfo, bool>? nodeFilter = null)
 	{
 		if (_breakpointMappings == null || _breakpointMappings.Breakpoints.Count == 0)
 			return;
@@ -375,8 +385,20 @@ public void TrySetBreakpointsForLoadedModules()
 			// Get all app domains
 			var appDomains = CurrentProcess.AppDomains.ToArray();
 
-			// For each breakpoint mapping, try to set a breakpoint
-			foreach (var bpInfo in _breakpointMappings.Breakpoints)
+			// For each breakpoint mapping, check if we should set a breakpoint
+			// Only process nodes that:
+			// 1. Pass the filter (if provided), AND
+			// 2. Should have a breakpoint (checked via ShouldSetBreakpointForNode delegate)
+			var breakpointsToConsider = nodeFilter != null 
+				? _breakpointMappings.Breakpoints.Where(nodeFilter)
+				: _breakpointMappings.Breakpoints;
+			
+			// Further filter by ShouldSetBreakpointForNode delegate
+			var breakpointsToSet = breakpointsToConsider
+				.Where(bp => ShouldSetBreakpointForNode == null || ShouldSetBreakpointForNode(bp.NodeId))
+				.ToList();
+				
+			foreach (var bpInfo in breakpointsToSet)
 			{
 				// Skip if already set
 				if (_activeBreakpoints.ContainsKey(bpInfo.NodeId))
@@ -448,6 +470,65 @@ public void TrySetBreakpointsForLoadedModules()
 		}
 	}
 
+	/// <summary>
+	/// Dynamically sets a breakpoint for a specific node during an active debug session.
+	/// This can be called after the process has started to add a breakpoint on-the-fly.
+	/// </summary>
+	/// <param name="nodeId">The ID of the node to set a breakpoint on.</param>
+	/// <returns>True if the breakpoint was set successfully, false otherwise.</returns>
+	public bool SetBreakpointForNode(string nodeId)
+	{
+		if (_breakpointMappings == null)
+			return false;
+			
+		// Find the breakpoint info for this node
+		var bpInfo = _breakpointMappings.Breakpoints.FirstOrDefault(bp => bp.NodeId == nodeId);
+		if (bpInfo == null)
+			return false;
+			
+		// If already set, return true
+		if (_activeBreakpoints.ContainsKey(nodeId))
+			return true;
+			
+		// Set breakpoint for just this node
+		TrySetBreakpointsForLoadedModules(bp => bp.NodeId == nodeId);
+		
+		// Check if it was set successfully
+		return _activeBreakpoints.ContainsKey(nodeId);
+	}
+	
+	/// <summary>
+	/// Dynamically removes a breakpoint for a specific node during an active debug session.
+	/// </summary>
+	/// <param name="nodeId">The ID of the node to remove the breakpoint from.</param>
+	/// <returns>True if the breakpoint was removed successfully, false if it wasn't set.</returns>
+	public bool RemoveBreakpointForNode(string nodeId)
+	{
+		if (!_activeBreakpoints.TryGetValue(nodeId, out var breakpoint))
+			return false;
+			
+		try
+		{
+			// Deactivate and dispose the breakpoint
+			if (breakpoint != null)
+			{
+				breakpoint.Activate(false);
+				// Note: ClrDebug breakpoints don't have explicit dispose
+			}
+			
+			_activeBreakpoints.Remove(nodeId);
+			OnDebugCallback(new DebugCallbackEventArgs("BreakpointRemoved", 
+				$"Removed breakpoint for node {nodeId}"));
+			return true;
+		}
+		catch (Exception ex)
+		{
+			OnDebugCallback(new DebugCallbackEventArgs("BreakpointError", 
+				$"Failed to remove breakpoint for node {nodeId}: {ex.Message}"));
+			return false;
+		}
+	}
+	
 	/// <summary>
 	/// Attempts to set an actual ICorDebug breakpoint in a module.
 	/// </summary>

src/NodeDev.Core/Project.cs

@@ -493,6 +493,14 @@ public string GetScriptRunnerPath()
 
 				// Set breakpoint mappings from the build
 				_debugEngine.SetBreakpointMappings(_currentBreakpointMappings);
+				
+				// Set the delegate to check if a node should have a breakpoint
+				// This allows filtering breakpoints based on current node state
+				_debugEngine.ShouldSetBreakpointForNode = (nodeId) =>
+				{
+					var node = FindNodeById(nodeId);
+					return node?.HasBreakpoint ?? false;
+				};
 			}
 			catch (Exception ex)
 			{
@@ -668,6 +676,75 @@ public void ContinueExecution()
 			throw;
 		}
 	}
+	
+	/// <summary>
+	/// Dynamically sets a breakpoint on a specific node during an active debug session.
+	/// This allows adding breakpoints after the process has started.
+	/// </summary>
+	/// <param name="nodeId">The ID of the node to set a breakpoint on.</param>
+	/// <returns>True if the breakpoint was set successfully, false otherwise.</returns>
+	public bool SetBreakpointForNode(string nodeId)
+	{
+		if (!IsHardDebugging)
+			throw new InvalidOperationException("Cannot set breakpoints when not debugging.");
+			
+		if (_debugEngine == null)
+			return false;
+			
+		// Find the node and ensure it has a breakpoint decoration
+		var node = FindNodeById(nodeId);
+		if (node == null)
+			return false;
+			
+		// Set the breakpoint decoration if not already set
+		if (!node.HasBreakpoint)
+			node.ToggleBreakpoint();
+		
+		// Tell the debug engine to set the breakpoint
+		return _debugEngine.SetBreakpointForNode(nodeId);
+	}
+	
+	/// <summary>
+	/// Dynamically removes a breakpoint from a specific node during an active debug session.
+	/// </summary>
+	/// <param name="nodeId">The ID of the node to remove the breakpoint from.</param>
+	/// <returns>True if the breakpoint was removed successfully, false if it wasn't set.</returns>
+	public bool RemoveBreakpointForNode(string nodeId)
+	{
+		if (!IsHardDebugging)
+			throw new InvalidOperationException("Cannot remove breakpoints when not debugging.");
+			
+		if (_debugEngine == null)
+			return false;
+			
+		// Find the node and remove the breakpoint decoration
+		var node = FindNodeById(nodeId);
+		if (node != null && node.HasBreakpoint)
+			node.ToggleBreakpoint();
+		
+		// Tell the debug engine to remove the breakpoint
+		return _debugEngine.RemoveBreakpointForNode(nodeId);
+	}
+	
+	/// <summary>
+	/// Finds a node by its ID across all classes in the project.
+	/// </summary>
+	/// <param name="nodeId">The ID of the node to find.</param>
+	/// <returns>The node if found, null otherwise.</returns>
+	private Node? FindNodeById(string nodeId)
+	{
+		foreach (var nodeClass in Classes)
+		{
+			// Check methods
+			foreach (var method in nodeClass.Methods)
+			{
+				if (method.Graph?.Nodes.TryGetValue(nodeId, out var node) == true)
+					return node;
+			}
+		}
+		
+		return null;
+	}
 
 	#endregion