scanner: Add context field to patch_hunk_line for better context diff handling

Add enum patch_line_context and context field to struct patch_hunk_line
to explicitly represent which file version a line belongs to:
- PATCH_CONTEXT_BOTH: Normal lines (applies to both old and new versions)
- PATCH_CONTEXT_OLD: Lines representing the old file state
- PATCH_CONTEXT_NEW: Lines representing the new file state

For context diffs, this eliminates ambiguity about changed lines ('!'):
- Old section lines are emitted with PATCH_CONTEXT_OLD
- New section lines are emitted with PATCH_CONTEXT_NEW
- Each line is emitted exactly once with appropriate context

This simplifies consumer logic by providing explicit context information
instead of requiring manual handling of context diff dual-nature semantics.

Updated scanner_debug utility and documentation to reflect the new API.
Fixed test expectations to match the corrected emission behavior.

Assisted-by: Cursor

Author: twaugh

README_scanner_debug.md

@@ -56,11 +56,13 @@ Complete patch headers (file names, types, Git metadata)
 Hunk range information (`@@ -1,3 +1,3 @@` or `*** 1,3 ****`)
 
 ### HUNK_LINE
-Individual patch lines with type:
-- **Context (' ')**: Unchanged lines
-- **Added ('+')**: Added lines
-- **Removed ('-')**: Removed lines
-- **Changed ('!')**: Changed lines (context diffs)
+Individual patch lines with type and context:
+- **Context (' ')**: Unchanged lines (context: both)
+- **Added ('+')**: Added lines (context: both)
+- **Removed ('-')**: Removed lines (context: both)
+- **Changed ('!')**: Changed lines (context diffs only)
+  - Emitted twice: first as context "old", then as context "new"
+  - Same line content, different context indicating old vs new version
 
 ### BINARY
 Binary patch markers (`Binary files differ`, `GIT binary patch`)
@@ -106,10 +108,10 @@ Scanner Debug Output for: example.patch
   Range: -1,3 +1,3
 
 [HUNK_LINE] HUNK_LINE (line 4, pos 38)
-  Type: Context (' ') Content: "line1\n"
+  Type: Context (' ') Context: both Content: "line1\n"
 
 [HUNK_LINE] HUNK_LINE (line 5, pos 45)
-  Type: Removed ('-') Content: "old line\n"
+  Type: Removed ('-') Context: both Content: "old line\n"
 
 ================================================================
 Summary: Processed 6 events, scanner finished normally

src/patch_scanner.c

@@ -219,7 +219,11 @@ static int scanner_context_buffer_emit_next(patch_scanner_t *scanner, const patc
     if (scanner->context_buffer_emit_index < scanner->context_buffer_count) {
         /* Emit the next buffered line */
         scanner_init_content(scanner, PATCH_CONTENT_HUNK_LINE);
-        scanner->current_content.data.line = &scanner->context_buffer[scanner->context_buffer_emit_index];
+
+        /* Get the buffered line - context was set correctly when buffered */
+        struct patch_hunk_line *buffered_line = &scanner->context_buffer[scanner->context_buffer_emit_index];
+
+        scanner->current_content.data.line = buffered_line;
         *content = &scanner->current_content;
         scanner->context_buffer_emit_index++;
         return PATCH_SCAN_OK;
@@ -528,13 +532,16 @@ int patch_scanner_next(patch_scanner_t *scanner, const patch_content_t **content
 
                 /* For context diffs, check if we should buffer this line */
                 if (scanner->context_buffering) {
-                    /* Buffer this line instead of emitting it */
+                    /* Buffer this line for later emission */
                     result = scanner_context_buffer_add(scanner, &scanner->current_line);
                     if (result != PATCH_SCAN_OK) {
                         scanner->state = STATE_ERROR;
                         return result;
                     }
-                    /* Continue to next line without emitting */
+
+                    /* All lines in old section are buffered for later emission - no immediate emission */
+
+                    /* For other lines, continue to next line without emitting */
                     continue;
                 }
 
@@ -1396,6 +1403,22 @@ static int scanner_emit_hunk_line(patch_scanner_t *scanner, const char *line)
     scanner->current_line.type = (enum patch_hunk_line_type)line_type;
     scanner->current_line.position = scanner->current_position;
 
+    /* Set context based on line type and diff format */
+    if (line_type == '!' && scanner->current_headers.type == PATCH_TYPE_CONTEXT) {
+        /* For context diff changed lines, context depends on when we emit:
+         * - During buffering (old section): PATCH_CONTEXT_OLD
+         * - During emission from buffer (new section): PATCH_CONTEXT_NEW
+         */
+        if (scanner->context_buffering) {
+            scanner->current_line.context = PATCH_CONTEXT_OLD;
+        } else {
+            scanner->current_line.context = PATCH_CONTEXT_NEW;
+        }
+    } else {
+        /* Normal lines apply to both old and new file versions */
+        scanner->current_line.context = PATCH_CONTEXT_BOTH;
+    }
+
     /* Populate full line including prefix, excluding trailing newline */
     scanner->current_line.line = line;
     size_t line_len = strlen(line);

src/patch_scanner.h

@@ -86,6 +86,13 @@ enum patch_hunk_line_type {
     PATCH_LINE_NO_NEWLINE = '\\' /* No newline marker */
 };
 
+/* Context for patch lines (especially important for context diff changed lines) */
+enum patch_line_context {
+    PATCH_CONTEXT_BOTH = 0,      /* Normal lines (space, +, -, \) - applies to both old and new */
+    PATCH_CONTEXT_OLD,           /* This represents the "old" version of a changed line (!) */
+    PATCH_CONTEXT_NEW            /* This represents the "new" version of a changed line (!) */
+};
+
 /**
  * Complete patch headers information.
  *
@@ -177,6 +184,19 @@ struct patch_hunk {
  * - PATCH_LINE_CHANGED ('!'): Line changed between files (context diffs only)
  * - PATCH_LINE_NO_NEWLINE ('\\'): Not a real line, indicates previous line has no newline
  *
+ * CONTEXT HANDLING:
+ * - context indicates which version of the file this line represents
+ * - PATCH_CONTEXT_BOTH: Normal lines (applies to both old and new file versions)
+ * - PATCH_CONTEXT_OLD: For PATCH_LINE_CHANGED, this is the "old" version of the line
+ * - PATCH_CONTEXT_NEW: For PATCH_LINE_CHANGED, this is the "new" version of the line
+ *
+ * CONTEXT DIFF DUAL EMISSION:
+ * - For context diffs, changed lines (!) are emitted twice with identical content:
+ *   1. First emission: during old section parsing (context = PATCH_CONTEXT_OLD)
+ *   2. Second emission: during new section parsing (context = PATCH_CONTEXT_NEW)
+ * - This allows consumers to easily filter for "before" vs "after" views
+ * - Unified diffs don't have this behavior (changed lines appear as separate - and + lines)
+ *
  * CONTENT HANDLING:
  * - line points to the FULL original line INCLUDING the +/- prefix character
  * - length is the byte length of the full line (includes prefix, excludes newline)
@@ -186,6 +206,7 @@ struct patch_hunk {
  */
 struct patch_hunk_line {
     enum patch_hunk_line_type type; /* Line operation type (space, +, -, !, \) */
+    enum patch_line_context context; /* Which file version this line represents */
     const char *line;            /* Full original line INCLUDING prefix (NOT null-terminated) */
     size_t length;               /* Length of full line in bytes (includes prefix, excludes newline) */
     long position;               /* Byte offset in input where this line appears */

src/scanner_debug.c

@@ -423,6 +423,16 @@ static void print_hunk_line_info(const struct patch_hunk_line *line)
     printf("  %sType:%s %s", C(COLOR_BOLD), C(COLOR_RESET),
            hunk_line_type_name(line->type));
 
+    /* Show context information */
+    const char *context_name;
+    switch (line->context) {
+        case PATCH_CONTEXT_BOTH: context_name = "both"; break;
+        case PATCH_CONTEXT_OLD: context_name = "old"; break;
+        case PATCH_CONTEXT_NEW: context_name = "new"; break;
+        default: context_name = "unknown"; break;
+    }
+    printf(" %sContext:%s %s", C(COLOR_BOLD), C(COLOR_RESET), context_name);
+
     if (show_content && line->line && line->length > 0) {
         printf(" %sContent:%s ", C(COLOR_BOLD), C(COLOR_RESET));
         /* Extract content without prefix for display */

tests/scanner/test_basic.c

@@ -1484,7 +1484,7 @@ static void test_context_diff_multi_hunk_parsing(void)
     /* Basic structure validation */
     assert(header_count == 1);           /* file1 */
     assert(hunk_header_count == 1);      /* one hunk */
-    assert(change_line_count == 2);      /* ! a and ! b */
+    assert(change_line_count == 2);      /* ! a (old context), ! b (new context) */
 
     /* The key assertions: change lines were found as HUNK_LINE (not NON-PATCH) */
     assert(found_change_a == 1);         /* ! a was parsed as HUNK_LINE */