Merge pull request #100 from DongyuZhao/copilot/fix-72f8db3b-ef02-4174-9cf9-ef4bf1e447be

Implement enhanced list builder with AST traversal and context-aware indentation handling

Author: DongyuZhao

Sources/CodeParserCollection/Markdown/MarkdownConstructState.swift

@@ -22,6 +22,9 @@ public class MarkdownConstructState: CodeConstructState {
   /// Stack for nested list processing
   public var listStack: [ListNode] = []
   public var currentDefinitionList: DefinitionListNode?
+  
+  /// Enhanced list context tracking for better indentation and nesting management
+  public var listContextStack: [ListContextInfo] = []
 
   /// Indicates the last consumed line break formed a blank line (two or more consecutive newlines)
   public var lastWasBlankLine: Bool = false
@@ -129,3 +132,25 @@ public struct HTMLBlockTypeInfo {
     self.endCondition = endCondition
   }
 }
+
+/// Enhanced list context information for better nesting and indentation management
+public struct ListContextInfo {
+  /// The list node itself
+  public let list: ListNode
+  /// The parent list item that contains this list (nil for top-level lists)
+  public let parentListItem: ListItemNode?
+  /// The calculated indentation level for content in this list context
+  public let contentIndent: Int
+  /// The nesting level (1 for top-level, 2 for first nested, etc.)
+  public let level: Int
+  /// The marker type for compatibility checking
+  public let markerType: String
+  
+  public init(list: ListNode, parentListItem: ListItemNode?, contentIndent: Int, level: Int, markerType: String) {
+    self.list = list
+    self.parentListItem = parentListItem
+    self.contentIndent = contentIndent
+    self.level = level
+    self.markerType = markerType
+  }
+}

Sources/CodeParserCollection/Markdown/Nodes/MarkdownBlockBuilder.swift

@@ -23,15 +23,15 @@ public class MarkdownBlockBuilder: CodeNodeBuilder {
     let rules: [BlockRule] = [
       // Open containers first (strip markers, reprocess line)
       .init(builder: MarkdownBlockQuoteBuilder(), phase: .openContainer, priority: 10),
-      .init(builder: MarkdownListBuilder(), phase: .openContainer, priority: 20),
-      .init(builder: MarkdownListItemBuilder(), phase: .openContainer, priority: 30),
+      .init(builder: MarkdownUnifiedListBuilder(), phase: .openContainer, priority: 20),
 
       // Leaf on line
       .init(builder: MarkdownEOFBuilder(), phase: .leafOnLine, priority: 0),
       .init(builder: MarkdownReferenceLinkDefinitionBuilder(), phase: .leafOnLine, priority: 5),
       .init(builder: MarkdownFencedCodeBlockBuilder(), phase: .leafOnLine, priority: 10),
       .init(builder: MarkdownATXHeadingBuilder(), phase: .leafOnLine, priority: 20),
       .init(builder: MarkdownThematicBreakBuilder(), phase: .leafOnLine, priority: 30),
+      .init(builder: MarkdownSetextHeadingBuilder(), phase: .leafOnLine, priority: 32),
       .init(builder: MarkdownHTMLBlockBuilder(), phase: .leafOnLine, priority: 35),
       .init(builder: MarkdownIndentedCodeBlockBuilder(), phase: .leafOnLine, priority: 40),
       .init(builder: MarkdownParagraphBuilder(), phase: .leafOnLine, priority: 1000),  // fallback
@@ -126,8 +126,11 @@ public class MarkdownBlockBuilder: CodeNodeBuilder {
               if phase == .openContainer {
                 // Continue to next phase without returning; break out of builder loop
                 break
+              } else if phase == .leafOnLine {
+                // For leafOnLine phase, allow proceeding to postParagraph phase
+                break
               } else {
-                // For leaf/post phases, we're done with this line
+                // For postParagraph phase, we're done with this line
                 return
               }
             }

Sources/CodeParserCollection/Markdown/Nodes/MarkdownIndentedCodeBlockBuilder.swift

@@ -71,6 +71,16 @@ public class MarkdownIndentedCodeBlockBuilder: CodeNodeBuilder {
     if context.current.element == .paragraph {
       return false
     }
+    
+    // Check if we're in a list item context - indented content should be treated as list continuation
+    // rather than code block if the indentation matches list item requirements
+    if let listItem = findContainingListItem(context.current) {
+      // If the indentation is exactly what's needed for list item continuation,
+      // don't create a code block - let list continuation handle it
+      if indentationSpaces < listItem.contentIndent + 4 {
+        return false
+      }
+    }
 
     // If we reached end of tokens, this is just indented whitespace - not a code block
     guard index < context.tokens.count else {
@@ -131,4 +141,15 @@ public class MarkdownIndentedCodeBlockBuilder: CodeNodeBuilder {
 
     return true
   }
+
+  private func findContainingListItem(_ node: CodeNode<MarkdownNodeElement>) -> ListItemNode? {
+    var current: CodeNode<MarkdownNodeElement>? = node
+    while let n = current {
+      if let listItem = n as? ListItemNode {
+        return listItem
+      }
+      current = n.parent
+    }
+    return nil
+  }
 }