fix: Comprehensive fixes from code review findings

Chunker improvements:
- Code chunker: implement MaxChunkSize, MinChunkSize, ChunkGranularity
- Code chunker: add granularity validation with constants
- Code chunker: fix extractReceiver for generics and complex types
- Markdown chunker: use original heading level in continuations
- Markdown chunker: add ChunkOverlap config for context preservation

Entity extraction improvements:
- Add word boundaries to patterns to prevent partial matches
- Add missing entity types: Version, Email, Date, Commit, IP
- Update Extract to handle capturing groups properly
- Add priority system for new entity types

Enricher improvements:
- Add ContinueOnError option to enricher chain
- Make Chain.Add() thread-safe with sync.RWMutex
- Add NewXxxValidated() constructors for error handling
- Fix DRY violation in relationship enricher (shared enrichInternal)
- Add document context to error messages
- Add missing relationship types: Calls, Implements, Extends, etc.

Summarizer improvements:
- UTF-8 safe truncation using runes instead of bytes
- Add document ID to error context

Test updates:
- Update nil constructor tests to expect nil return
- Fix URL trailing punctuation test expectation
- Update custom pattern test to use non-conflicting pattern

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

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: randalmurphal

pkg/graphrag/indexing/chunker/code/go.go

@@ -70,6 +70,11 @@ func (c *GoChunker) ChunkCode(ctx context.Context, id, filePath, content string)
 	default:
 	}
 
+	// Handle file-level granularity early
+	if c.config.ChunkGranularity == GranularityFile {
+		return c.chunkAsFile(id, filePath, content), nil
+	}
+
 	// Parse the Go source file
 	fset := token.NewFileSet()
 	file, err := parser.ParseFile(fset, filePath, content, parser.ParseComments)
@@ -131,9 +136,206 @@ func (c *GoChunker) ChunkCode(ctx context.Context, id, filePath, content string)
 		}
 	}
 
+	// Apply granularity grouping if type-level
+	if c.config.ChunkGranularity == GranularityType {
+		chunks = c.groupByType(chunks, id)
+	}
+
+	// Apply size limits
+	chunks = c.applySizeLimits(chunks, id)
+
 	return chunks, nil
 }
 
+// chunkAsFile returns the entire file as a single chunk.
+func (c *GoChunker) chunkAsFile(id, filePath, content string) []CodeChunk {
+	return []CodeChunk{{
+		Chunk: chunker.Chunk{
+			ID:       c.generateID(id, "file", 0),
+			Content:  content,
+			Index:    0,
+			ParentID: id,
+			Metadata: map[string]any{
+				"symbol_type": string(SymbolPackage),
+				"granularity": GranularityFile,
+			},
+		},
+		Language:   "go",
+		SymbolType: SymbolPackage,
+		FilePath:   filePath,
+		StartLine:  1,
+	}}
+}
+
+// groupByType groups types with their methods into single chunks.
+func (c *GoChunker) groupByType(chunks []CodeChunk, parentID string) []CodeChunk {
+	// Map receiver types to their methods
+	typeMethods := make(map[string][]CodeChunk)
+	var result []CodeChunk
+
+	// First pass: collect methods by receiver type
+	for _, chunk := range chunks {
+		if chunk.SymbolType == SymbolMethod && chunk.Receiver != "" {
+			// Strip pointer prefix for grouping
+			baseReceiver := strings.TrimPrefix(chunk.Receiver, "*")
+			// Also strip generic suffixes
+			if idx := strings.Index(baseReceiver, "["); idx > 0 {
+				baseReceiver = baseReceiver[:idx]
+			}
+			typeMethods[baseReceiver] = append(typeMethods[baseReceiver], chunk)
+		}
+	}
+
+	// Second pass: merge types with their methods
+	newIdx := 0
+	usedMethods := make(map[string]bool)
+
+	for _, chunk := range chunks {
+		if chunk.SymbolType == SymbolMethod {
+			continue // Skip methods, they'll be merged with types
+		}
+
+		if chunk.SymbolType == SymbolTypeDecl {
+			// Check if this type has methods
+			if methods, ok := typeMethods[chunk.SymbolName]; ok && len(methods) > 0 {
+				// Merge type with its methods
+				var combined strings.Builder
+				combined.WriteString(chunk.Content)
+
+				for _, m := range methods {
+					combined.WriteString("\n\n")
+					combined.WriteString(m.Content)
+					usedMethods[m.ID] = true
+				}
+
+				merged := chunk
+				merged.Chunk.Content = combined.String()
+				merged.Chunk.Index = newIdx
+				merged.Chunk.ID = c.generateID(parentID, chunk.SymbolName+"_with_methods", newIdx)
+				merged.Chunk.Metadata["method_count"] = len(methods)
+				result = append(result, merged)
+				newIdx++
+				continue
+			}
+		}
+
+		// Keep non-method, non-merged chunks
+		chunk.Chunk.Index = newIdx
+		result = append(result, chunk)
+		newIdx++
+	}
+
+	// Add any orphan methods (methods without a type in this file)
+	for _, chunk := range chunks {
+		if chunk.SymbolType == SymbolMethod && !usedMethods[chunk.ID] {
+			chunk.Chunk.Index = newIdx
+			result = append(result, chunk)
+			newIdx++
+		}
+	}
+
+	return result
+}
+
+// applySizeLimits applies MaxChunkSize splitting and MinChunkSize combining.
+func (c *GoChunker) applySizeLimits(chunks []CodeChunk, parentID string) []CodeChunk {
+	// Skip if no size limits configured
+	if c.config.MaxChunkSize <= 0 && c.config.MinChunkSize <= 0 {
+		return chunks
+	}
+
+	var result []CodeChunk
+	newIdx := 0
+
+	for i := 0; i < len(chunks); i++ {
+		chunk := chunks[i]
+
+		// Handle MaxChunkSize: split large chunks
+		if c.config.MaxChunkSize > 0 && len(chunk.Content) > c.config.MaxChunkSize {
+			splitChunks := c.splitLargeChunk(chunk, parentID, &newIdx)
+			result = append(result, splitChunks...)
+			continue
+		}
+
+		// Handle MinChunkSize: combine small chunks
+		if c.config.MinChunkSize > 0 && len(chunk.Content) < c.config.MinChunkSize {
+			// Try to combine with next chunk if it's also small and same type category
+			if i+1 < len(chunks) {
+				next := chunks[i+1]
+				combinedSize := len(chunk.Content) + len(next.Content) + 2 // +2 for newlines
+
+				// Only combine if result won't exceed MaxChunkSize (if set)
+				canCombine := c.config.MaxChunkSize <= 0 || combinedSize <= c.config.MaxChunkSize
+				// Only combine similar types (both consts, both vars, etc.)
+				sameCategory := chunk.SymbolType == next.SymbolType
+
+				if canCombine && sameCategory && len(next.Content) < c.config.MinChunkSize {
+					combined := chunk
+					combined.Content = chunk.Content + "\n\n" + next.Content
+					combined.SymbolName = chunk.SymbolName + ", " + next.SymbolName
+					combined.Chunk.Index = newIdx
+					combined.Chunk.ID = c.generateID(parentID, combined.SymbolName, newIdx)
+					combined.Chunk.Metadata["combined"] = true
+					result = append(result, combined)
+					newIdx++
+					i++ // Skip next chunk since we combined it
+					continue
+				}
+			}
+		}
+
+		// Keep chunk as-is
+		chunk.Chunk.Index = newIdx
+		result = append(result, chunk)
+		newIdx++
+	}
+
+	return result
+}
+
+// splitLargeChunk splits a chunk that exceeds MaxChunkSize.
+func (c *GoChunker) splitLargeChunk(chunk CodeChunk, parentID string, idx *int) []CodeChunk {
+	content := chunk.Content
+	maxSize := c.config.MaxChunkSize
+	var result []CodeChunk
+
+	partNum := 0
+	for len(content) > 0 {
+		// Find split point (prefer line boundaries)
+		splitAt := maxSize
+		if splitAt > len(content) {
+			splitAt = len(content)
+		} else {
+			// Look for last newline within limit
+			lastNewline := strings.LastIndex(content[:splitAt], "\n")
+			if lastNewline > maxSize/2 { // Only use if not too far back
+				splitAt = lastNewline + 1
+			}
+		}
+
+		part := content[:splitAt]
+		content = content[splitAt:]
+
+		partChunk := chunk
+		partChunk.Content = strings.TrimSpace(part)
+		partChunk.Chunk.Index = *idx
+		partChunk.Chunk.ID = c.generateID(parentID, fmt.Sprintf("%s_part%d", chunk.SymbolName, partNum), *idx)
+		partChunk.Chunk.Metadata["part"] = partNum
+		partChunk.Chunk.Metadata["split"] = true
+
+		if partNum > 0 {
+			// Add context header for continuation
+			partChunk.Content = fmt.Sprintf("// %s (continued)\n%s", chunk.SymbolName, partChunk.Content)
+		}
+
+		result = append(result, partChunk)
+		*idx++
+		partNum++
+	}
+
+	return result
+}
+
 // extractPackage creates a chunk for the package declaration.
 func (c *GoChunker) extractPackage(fset *token.FileSet, file *ast.File, id, filePath, content string, idx int) *CodeChunk {
 	var builder strings.Builder
@@ -393,13 +595,35 @@ func (c *GoChunker) extractFuncDecl(fset *token.FileSet, file *ast.File, fn *ast
 }
 
 // extractReceiver extracts the receiver type from a method.
+// Handles value receivers, pointer receivers, and generic receivers.
 func (c *GoChunker) extractReceiver(field *ast.Field) string {
-	switch t := field.Type.(type) {
+	return c.typeToReceiverString(field.Type)
+}
+
+// typeToReceiverString converts a type expression to a receiver string.
+func (c *GoChunker) typeToReceiverString(expr ast.Expr) string {
+	switch t := expr.(type) {
 	case *ast.Ident:
 		return t.Name
 	case *ast.StarExpr:
+		inner := c.typeToReceiverString(t.X)
+		if inner != "" {
+			return "*" + inner
+		}
+	case *ast.IndexExpr:
+		// Generic type with single type parameter: Type[T]
+		if ident, ok := t.X.(*ast.Ident); ok {
+			return ident.Name + "[T]"
+		}
+	case *ast.IndexListExpr:
+		// Generic type with multiple type parameters: Type[T, U]
 		if ident, ok := t.X.(*ast.Ident); ok {
-			return "*" + ident.Name
+			return ident.Name + "[...]"
+		}
+	case *ast.SelectorExpr:
+		// Qualified type: pkg.Type
+		if x, ok := t.X.(*ast.Ident); ok {
+			return x.Name + "." + t.Sel.Name
 		}
 	}
 	return ""

pkg/graphrag/indexing/chunker/code/options.go

@@ -1,5 +1,24 @@
 package code
 
+// Granularity constants for chunk granularity.
+const (
+	GranularityFunction = "function" // Each function/method is a separate chunk (default)
+	GranularityType     = "type"     // Each type and its methods are grouped together
+	GranularityFile     = "file"     // Entire file is one chunk
+)
+
+// validGranularities is the set of valid granularity values.
+var validGranularities = map[string]bool{
+	GranularityFunction: true,
+	GranularityType:     true,
+	GranularityFile:     true,
+}
+
+// IsValidGranularity checks if a granularity value is valid.
+func IsValidGranularity(g string) bool {
+	return validGranularities[g]
+}
+
 // Option configures a code chunker.
 type Option func(*Config)
 
@@ -44,13 +63,14 @@ func WithMinChunkSize(size int) Option {
 }
 
 // WithChunkGranularity sets the chunking level.
-// Valid values:
-//   - "function": Each function/method is a separate chunk (default)
-//   - "type": Each type and its methods are grouped together
-//   - "file": Entire file is one chunk
+// Valid values: GranularityFunction, GranularityType, GranularityFile.
+// Invalid values are ignored (use IsValidGranularity to check beforehand).
 func WithChunkGranularity(granularity string) Option {
 	return func(c *Config) {
-		c.ChunkGranularity = granularity
+		if IsValidGranularity(granularity) {
+			c.ChunkGranularity = granularity
+		}
+		// Invalid values are silently ignored - use IsValidGranularity to validate
 	}
 }