feat(parser): Implement chunk-based CSS text scanner to avoid Tree-sitter memory explosions

- Extracted CSS parsing from html/analyzer.go to a dedicated css/analyzer.go
- Replaces GLR AST generation with linear bracket-depth text scanning
- Caps huge CSS rule chunks to 8KB to prevent vector DB overload
- Removed old unused css_regex.go implementation
- Registered the new generic CSS parser globally in the daemon

Resolves Trello Task 1, Task 2, Task 3

Author: doITmagic

cmd/rag-code-mcp/main.go

@@ -16,7 +16,7 @@ import (
 )
 
 var (
-	Version = "2.1.78"
+	Version = "2.1.79"
 	Commit  = "none"
 	Date    = "24.10.2025"
 )

internal/daemon/run.go

@@ -23,6 +23,7 @@ import (
 	"github.com/doITmagic/rag-code-mcp/internal/utils"
 	"github.com/doITmagic/rag-code-mcp/pkg/indexer"
 	"github.com/doITmagic/rag-code-mcp/pkg/llm"
+	_ "github.com/doITmagic/rag-code-mcp/pkg/parser/css"
 	_ "github.com/doITmagic/rag-code-mcp/pkg/parser/docs"
 	_ "github.com/doITmagic/rag-code-mcp/pkg/parser/go"
 	_ "github.com/doITmagic/rag-code-mcp/pkg/parser/html"

pkg/parser/css/analyzer.go

@@ -0,0 +1,157 @@
+package css
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/doITmagic/rag-code-mcp/pkg/parser"
+)
+
+func init() {
+	parser.Register(NewAnalyzer())
+}
+
+// Analyzer implementeaza procesarea pe bucati (chunk-based) a fisierelor CSS/SCSS/LESS.
+// Fara sa depinda de Tree-sitter, nu face OOM nici macar la bundle-uri gigantice.
+type Analyzer struct{}
+
+func NewAnalyzer() *Analyzer {
+	return &Analyzer{}
+}
+
+func (a *Analyzer) Name() string {
+	return "css"
+}
+
+func (a *Analyzer) CanHandle(filePath string) bool {
+	ext := strings.ToLower(filepath.Ext(filePath))
+	return ext == ".css" || ext == ".scss" || ext == ".less" || ext == ".sass"
+}
+
+func (a *Analyzer) Analyze(ctx context.Context, path string) (*parser.Result, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read css: %w", err)
+	}
+
+	text := string(content)
+	if strings.TrimSpace(text) == "" {
+		return &parser.Result{Language: "css"}, nil
+	}
+
+	var symbols []parser.Symbol
+
+	var selectorBuilder strings.Builder
+	var contentBuilder strings.Builder
+	braceDepth := 0
+	startLine := 1
+	currentLine := 1
+	inComment := false
+
+	baseName := filepath.Base(path)
+
+	for i := 0; i < len(text); i++ {
+		c := text[i]
+
+		if c == '\n' {
+			currentLine++
+		}
+
+		// Skip over slash-star comments
+		if !inComment && c == '/' && i+1 < len(text) && text[i+1] == '*' {
+			inComment = true
+			i++ // skip '*'
+			continue
+		}
+		if inComment && c == '*' && i+1 < len(text) && text[i+1] == '/' {
+			inComment = false
+			i++ // skip '/'
+			continue
+		}
+		if inComment {
+			continue
+		}
+
+		if c == '{' {
+			if braceDepth == 0 {
+				contentBuilder.WriteByte(c)
+			} else {
+				contentBuilder.WriteByte(c)
+			}
+			braceDepth++
+			continue
+		}
+
+		if c == '}' {
+			braceDepth--
+			contentBuilder.WriteByte(c)
+
+			if braceDepth == 0 {
+				selector := strings.TrimSpace(selectorBuilder.String())
+				if len(selector) > 200 {
+					selector = selector[:197] + "..."
+				}
+
+				blockContent := strings.TrimSpace(contentBuilder.String())
+				if len(blockContent) > 8192 {
+					blockContent = blockContent[:8192] + "\n...[TRUNCATED]"
+				}
+
+				if selector != "" {
+					symbols = append(symbols, parser.Symbol{
+						Name:      baseName,
+						Type:      "style_rule",
+						FilePath:  path,
+						Language:  "css",
+						Content:   selector + " " + blockContent,
+						Signature: selector,
+						StartLine: startLine,
+						EndLine:   currentLine,
+						IsPublic:  true,
+						Metadata: map[string]interface{}{
+							"selector": selector,
+						},
+					})
+				}
+
+				selectorBuilder.Reset()
+				contentBuilder.Reset()
+				startLine = currentLine
+			}
+			continue
+		}
+
+		if braceDepth == 0 {
+			selectorBuilder.WriteByte(c)
+		} else {
+			contentBuilder.WriteByte(c)
+		}
+	}
+
+	// Any leftover content (like variables at the root without braces)
+	leftover := strings.TrimSpace(selectorBuilder.String())
+	if leftover != "" && len(symbols) == 0 {
+		if len(leftover) > 8192 {
+			leftover = leftover[:8192] + "\n...[TRUNCATED]"
+		}
+		symbols = append(symbols, parser.Symbol{
+			Name:      baseName,
+			Type:      "style_rule",
+			FilePath:  path,
+			Language:  "css",
+			Content:   leftover,
+			Signature: "global",
+			StartLine: startLine,
+			EndLine:   currentLine,
+			IsPublic:  true,
+		})
+	}
+
+	return &parser.Result{
+		Symbols:  symbols,
+		Language: "css",
+	}, nil
+}

pkg/parser/html/analyzer.go

@@ -99,88 +99,7 @@ func (a *Analyzer) Analyze(ctx context.Context, path string) (*pkgParser.Result,
 	}, nil
 }
 
-// analyzeCSS parses CSS/SCSS/LESS files using tree-sitter.
-func (a *Analyzer) analyzeCSS(path string) (*pkgParser.Result, error) {
-	content, err := os.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("css read %s: %w", path, err)
-	}
-
-	text := strings.TrimSpace(string(content))
-	if text == "" {
-		return &pkgParser.Result{Language: "html"}, nil
-	}
-
-	// Use tree-sitter for proper CSS/SCSS parsing
-	langInfo := grammars.DetectLanguage(path)
-	if langInfo == nil {
-		// Fallback: if tree-sitter doesn't recognize the extension, skip
-		return &pkgParser.Result{Language: "html"}, nil
-	}
-
-	langObj := langInfo.Language()
-	tsParser := a.getOrCreateParser(langInfo)
-	tree, err := tsParser.Parse(content)
-	if err != nil {
-		return nil, fmt.Errorf("css treesitter parse %s: %w", path, err)
-	}
-	defer tree.Release()
-
-	baseName := filepath.Base(path)
-	langName := langInfo.Name
-	var symbols []pkgParser.Symbol
-	root := tree.RootNode()
-
-	// Walk tree-sitter nodes, extracting rule blocks as symbols
-	for i := 0; i < root.ChildCount(); i++ {
-		node := root.Child(i)
-		nodeType := node.Type(langObj)
-		nodeText := strings.TrimSpace(node.Text(content))
 
-		if len(nodeText) < 5 {
-			continue
-		}
-
-		// Truncate very large blocks
-		if len(nodeText) > 4096 {
-			nodeText = nodeText[:4096] + "\n...[TRUNCATED]"
-		}
-
-		startLine := int(node.StartPoint().Row) + 1
-		endLine := int(node.EndPoint().Row) + 1
-
-		// Extract selector from CSS rule nodes
-		selector := nodeType
-		if node.ChildCount() > 0 {
-			firstChild := node.Child(0)
-			firstChildText := strings.TrimSpace(firstChild.Text(content))
-			if firstChildText != "" && len(firstChildText) < 200 {
-				selector = firstChildText
-			}
-		}
-
-		symbols = append(symbols, pkgParser.Symbol{
-			Name:      baseName,
-			Type:      "style_rule",
-			FilePath:  path,
-			Language:  langName,
-			Content:   nodeText,
-			Signature: selector,
-			StartLine: startLine,
-			EndLine:   endLine,
-			IsPublic:  true,
-			Metadata: map[string]interface{}{
-				"selector":  selector,
-				"node_type": nodeType,
-			},
-		})
-	}
-
-	return &pkgParser.Result{
-		Symbols:  symbols,
-		Language: "html",
-	}, nil
-}
 
 // CodeAnalyzer handles the heavy lifting of HTML analysis.
 type CodeAnalyzer struct{}

pkg/parser/html/css_regex.go

@@ -41,7 +41,7 @@ func TestRegistry(t *testing.T) {
 	t.Run("GetByFile", func(t *testing.T) {
 		assert.Equal(t, a1, GetByFile("test.go"))
 		assert.Equal(t, a2, GetByFile("main.py"))
-		assert.Nil(t, GetByFile("style.css"))
+		assert.Nil(t, GetByFile("style.unknown"))
 	})
 }