fix: skip oversized JSONL lines instead of failing the session (#20)

## Summary

- Replace `bufio.Scanner` with a custom `lineReader` that uses
`bufio.Reader.ReadLine()` to skip lines exceeding 64MB instead of
aborting the entire session parse
- Propagate I/O errors through `lineReader.Err()` (matching
`bufio.Scanner` pattern) rather than silently swallowing them
- Replace all three scan sites (Claude parser, Claude hints extractor,
Codex parser)

Closes #12

## Test plan

- [x] `TestLineReader` — normal lines, oversized skip, all oversized,
empty input, blank lines, no trailing newline, exact limit, one over
limit
- [x] `TestLineReaderIOError` — custom `io.Reader` that yields data then
returns a non-EOF error; verifies lines are returned and `Err()` exposes
the I/O error
- [x] `TestParseCodexSessionOversizedLineSkipped` — integration test
placing an oversized line between normal JSONL entries
- [x] All Go tests pass (`CGO_ENABLED=1 go test -tags fts5 ./...`)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: wesm

internal/parser/claude.go

@@ -1,8 +1,8 @@
 package parser
 
 import (
-	"bufio"
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
 	"strings"
@@ -13,7 +13,7 @@ import (
 
 const (
 	initialScanBufSize = 64 * 1024        // 64KB
-	maxScanTokenSize   = 20 * 1024 * 1024 // 20MB
+	maxLineSize        = 64 * 1024 * 1024 // 64MB
 )
 
 // ParseClaudeSession parses a Claude Code JSONL session file.
@@ -43,15 +43,12 @@ func ParseClaudeSession(
 		ordinal         int
 	)
 
-	scanner := bufio.NewScanner(f)
-	scanner.Buffer(
-		make([]byte, 0, initialScanBufSize), maxScanTokenSize,
-	)
+	lr := newLineReader(f, maxLineSize)
 
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.TrimSpace(line) == "" {
-			continue
+	for {
+		line, ok := lr.next()
+		if !ok {
+			break
 		}
 
 		if !gjson.Valid(line) {
@@ -137,9 +134,9 @@ func ParseClaudeSession(
 		}
 	}
 
-	if err := scanner.Err(); err != nil {
+	if err := lr.Err(); err != nil {
 		return ParsedSession{}, nil,
-			fmt.Errorf("scanning %s: %w", path, err)
+			fmt.Errorf("reading %s: %w", path, err)
 	}
 
 	sess := ParsedSession{
@@ -173,15 +170,12 @@ func ExtractClaudeProjectHints(
 	}
 	defer f.Close()
 
-	scanner := bufio.NewScanner(f)
-	scanner.Buffer(
-		make([]byte, 0, initialScanBufSize), maxScanTokenSize,
-	)
+	lr := newLineReader(f, maxLineSize)
 
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.TrimSpace(line) == "" {
-			continue
+	for {
+		line, ok := lr.next()
+		if !ok {
+			break
 		}
 		if !gjson.Valid(line) {
 			continue
@@ -198,6 +192,9 @@ func ExtractClaudeProjectHints(
 			}
 		}
 	}
+	if err := lr.Err(); err != nil {
+		log.Printf("reading hints from %s: %v", path, err)
+	}
 	return cwd, gitBranch
 }
 

internal/parser/codex.go

@@ -1,7 +1,6 @@
 package parser
 
 import (
-	"bufio"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -504,17 +503,13 @@ func ParseCodexSession(
 	}
 	defer f.Close()
 
-	scanner := bufio.NewScanner(f)
-	scanner.Buffer(
-		make([]byte, 0, initialScanBufSize), maxScanTokenSize,
-	)
-
+	lr := newLineReader(f, maxLineSize)
 	b := newCodexSessionBuilder(includeExec)
 
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.TrimSpace(line) == "" {
-			continue
+	for {
+		line, ok := lr.next()
+		if !ok {
+			break
 		}
 		if !gjson.Valid(line) {
 			continue
@@ -524,9 +519,9 @@ func ParseCodexSession(
 		}
 	}
 
-	if err := scanner.Err(); err != nil {
+	if err := lr.Err(); err != nil {
 		return nil, nil,
-			fmt.Errorf("scanning codex %s: %w", path, err)
+			fmt.Errorf("reading codex %s: %w", path, err)
 	}
 
 	sessionID := b.sessionID

internal/parser/linereader.go

@@ -0,0 +1,90 @@
+package parser
+
+import (
+	"bufio"
+	"io"
+)
+
+// lineReader reads JSONL files line by line, skipping lines that
+// exceed maxLen rather than aborting. The buffer starts small and
+// grows on demand up to maxLen. After iteration, call Err() to
+// check for I/O errors (as opposed to normal EOF).
+type lineReader struct {
+	r      *bufio.Reader
+	maxLen int
+	buf    []byte
+	err    error
+}
+
+func newLineReader(r io.Reader, maxLen int) *lineReader {
+	return &lineReader{
+		r:      bufio.NewReaderSize(r, initialScanBufSize),
+		maxLen: maxLen,
+		buf:    make([]byte, 0, initialScanBufSize),
+	}
+}
+
+// next returns the next line (without trailing newline) and true,
+// or ("", false) at EOF or read error. After the loop, call Err()
+// to distinguish EOF from I/O failure.
+func (lr *lineReader) next() (string, bool) {
+	for {
+		line, err := lr.readLine()
+		if err != nil {
+			if err != io.EOF {
+				lr.err = err
+			}
+			return "", false
+		}
+		if line != "" {
+			return line, true
+		}
+		// Empty line or skipped oversized line — continue.
+	}
+}
+
+// Err returns the first non-EOF read error encountered, or nil.
+func (lr *lineReader) Err() error {
+	return lr.err
+}
+
+// readLine reads a full line, returning "" for blank/oversized
+// lines and a non-nil error only at EOF or read failure.
+func (lr *lineReader) readLine() (string, error) {
+	lr.buf = lr.buf[:0]
+	oversized := false
+
+	for {
+		chunk, isPrefix, err := lr.r.ReadLine()
+		if err != nil {
+			if len(lr.buf) > 0 && err == io.EOF {
+				break
+			}
+			return "", err
+		}
+
+		if oversized {
+			if !isPrefix {
+				return "", nil // done skipping
+			}
+			continue
+		}
+
+		lr.buf = append(lr.buf, chunk...)
+
+		if len(lr.buf) > lr.maxLen {
+			oversized = true
+			lr.buf = lr.buf[:0]
+			if !isPrefix {
+				return "", nil
+			}
+			continue
+		}
+
+		if !isPrefix {
+			break
+		}
+	}
+
+	return string(lr.buf), nil
+}

internal/parser/linereader_test.go

@@ -0,0 +1,141 @@
+package parser
+
+import (
+	"errors"
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestLineReader(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		maxLen  int
+		want    []string
+	}{
+		{
+			"normal lines",
+			"aaa\nbbb\nccc\n",
+			100,
+			[]string{"aaa", "bbb", "ccc"},
+		},
+		{
+			"skips oversized line",
+			"short\n" + strings.Repeat("x", 50) + "\nafter\n",
+			30,
+			[]string{"short", "after"},
+		},
+		{
+			"all lines oversized",
+			strings.Repeat("a", 50) + "\n" +
+				strings.Repeat("b", 50) + "\n",
+			30,
+			nil,
+		},
+		{
+			"empty input",
+			"",
+			100,
+			nil,
+		},
+		{
+			"blank lines skipped",
+			"aaa\n\n\nbbb\n",
+			100,
+			[]string{"aaa", "bbb"},
+		},
+		{
+			"line without trailing newline",
+			"aaa\nbbb",
+			100,
+			[]string{"aaa", "bbb"},
+		},
+		{
+			"exact limit kept",
+			strings.Repeat("x", 30) + "\n",
+			30,
+			[]string{strings.Repeat("x", 30)},
+		},
+		{
+			"one over limit skipped",
+			strings.Repeat("x", 31) + "\n",
+			30,
+			nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			lr := newLineReader(
+				strings.NewReader(tt.input), tt.maxLen,
+			)
+			var got []string
+			for {
+				line, ok := lr.next()
+				if !ok {
+					break
+				}
+				got = append(got, line)
+			}
+			if len(got) != len(tt.want) {
+				t.Fatalf("got %d lines, want %d: %v",
+					len(got), len(tt.want), got)
+			}
+			for i := range got {
+				if got[i] != tt.want[i] {
+					t.Errorf("line[%d] = %q, want %q",
+						i, got[i], tt.want[i])
+				}
+			}
+		})
+	}
+}
+
+// errAfterReader yields data from buf, then returns errIO on the
+// next read.
+type errAfterReader struct {
+	buf   *strings.Reader
+	errIO error
+	done  bool
+}
+
+func (r *errAfterReader) Read(p []byte) (int, error) {
+	if r.done {
+		return 0, r.errIO
+	}
+	n, err := r.buf.Read(p)
+	if err == io.EOF {
+		r.done = true
+		return n, r.errIO
+	}
+	return n, err
+}
+
+func TestLineReaderIOError(t *testing.T) {
+	ioErr := errors.New("disk read failed")
+	r := &errAfterReader{
+		buf:   strings.NewReader("aaa\nbbb\n"),
+		errIO: ioErr,
+	}
+
+	lr := newLineReader(r, 100)
+	var got []string
+	for {
+		line, ok := lr.next()
+		if !ok {
+			break
+		}
+		got = append(got, line)
+	}
+
+	if len(got) != 2 {
+		t.Fatalf("got %d lines, want 2: %v", len(got), got)
+	}
+	if lr.Err() == nil {
+		t.Fatal("expected non-nil Err() after I/O failure")
+	}
+	if !errors.Is(lr.Err(), ioErr) {
+		t.Fatalf("Err() = %v, want %v", lr.Err(), ioErr)
+	}
+}