fix(gotemplate): address PR #47 review + Go↔Template AST linking

- Add scanner.Err() check to prevent silent data truncation
- Tighten regex patterns (reBlock/reTemplate/reRange

Author: razvan

pkg/parser/go/analyzer.go

@@ -231,7 +231,7 @@ func (ca *CodeAnalyzer) analyzeFunctionDecl(fset *token.FileSet, fn *doc.Func, a
 			info.Parameters = ca.extractParameters(fn.Decl.Type.Params)
 			info.Returns = ca.extractReturns(fn.Decl.Type.Results)
 		}
-		info.Calls = ca.extractCallsFromAST(astBody)
+		info.Calls, info.TemplateFiles = ca.extractCallsFromAST(astBody)
 	} else if fn.Decl != nil {
 		// Fallback to doc.Func Decl (won't have Body)
 		// Extract position information
@@ -761,6 +761,24 @@ func convertPackageInfoToChunks(pi *PackageInfo) []CodeChunk {
 				Type:       pkgParser.RelCalls,
 			})
 		}
+		// Template file dependencies: template.ParseFiles("layout.html") → RelDependency
+		for _, tplFile := range fn.TemplateFiles {
+			rels = append(rels, pkgParser.Relation{
+				TargetName: tplFile,
+				Type:       pkgParser.RelDependency,
+			})
+		}
+
+		metadata := map[string]any{
+			"receiver":  fn.Receiver,
+			"is_method": fn.IsMethod,
+			"params":    fn.Parameters,
+			"returns":   fn.Returns,
+			"examples":  fn.Examples,
+		}
+		if len(fn.TemplateFiles) > 0 {
+			metadata["template_files"] = fn.TemplateFiles
+		}
 
 		out = append(out, CodeChunk{
 			Type:      kind,
@@ -774,13 +792,7 @@ func convertPackageInfoToChunks(pi *PackageInfo) []CodeChunk {
 			Docstring: fn.Description,
 			Code:      fn.Code,
 			Relations: rels,
-			Metadata: map[string]any{
-				"receiver":  fn.Receiver,
-				"is_method": fn.IsMethod,
-				"params":    fn.Parameters,
-				"returns":   fn.Returns,
-				"examples":  fn.Examples,
-			},
+			Metadata:  metadata,
 		})
 	}
 
@@ -925,29 +937,52 @@ func (ca *CodeAnalyzer) extractCodeFromFile(filePath string, startLine, endLine
 	return strings.Join(lines, "\n"), nil
 }
 
-func (ca *CodeAnalyzer) extractCallsFromAST(body *ast.BlockStmt) []string {
+func (ca *CodeAnalyzer) extractCallsFromAST(body *ast.BlockStmt) ([]string, []string) {
 	if body == nil {
-		return nil
+		return nil, nil
 	}
 	var calls []string
+	var templateFiles []string
 	seen := make(map[string]bool)
+	seenTpl := make(map[string]bool)
+
+	// Template-related function names that receive file paths as string arguments.
+	templateFuncs := map[string]bool{
+		"ParseFiles": true, "ParseGlob": true,
+	}
 
 	ast.Inspect(body, func(n ast.Node) bool {
 		if call, ok := n.(*ast.CallExpr); ok {
 			var name string
+			var sel string // selector part (e.g. "template" in template.ParseFiles)
 			switch fun := call.Fun.(type) {
 			case *ast.Ident:
 				name = fun.Name
 			case *ast.SelectorExpr:
 				x := ca.typeToString(fun.X)
-				name = fmt.Sprintf("%s.%s", x, fun.Sel.Name)
+				sel = fun.Sel.Name
+				name = fmt.Sprintf("%s.%s", x, sel)
 			}
 			if name != "" && !seen[name] {
 				calls = append(calls, name)
 				seen[name] = true
 			}
+
+			// Extract template file paths from template.ParseFiles("a.html", "b.html")
+			// and similar calls (works on any receiver: t.ParseFiles, tpl.ParseFiles, etc.)
+			if templateFuncs[sel] {
+				for _, arg := range call.Args {
+					if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING {
+						path := strings.Trim(lit.Value, "\"`")
+						if path != "" && !seenTpl[path] {
+							seenTpl[path] = true
+							templateFiles = append(templateFiles, path)
+						}
+					}
+				}
+			}
 		}
 		return true
 	})
-	return calls
+	return calls, templateFiles
 }

pkg/parser/go/relations_test.go

@@ -100,3 +100,57 @@ func TestGoRelations_TypesAreCanonical(t *testing.T) {
 		}
 	}
 }
+
+const goTemplateUsageCode = `package web
+
+import "html/template"
+
+func RenderPage(w io.Writer, data any) error {
+	t, err := template.ParseFiles("templates/layout.html", "templates/header.html")
+	if err != nil {
+		return err
+	}
+	return t.Execute(w, data)
+}
+
+func RenderDashboard(w io.Writer, data any) error {
+	t := template.Must(template.ParseGlob("templates/dashboard/*.tmpl"))
+	return t.Execute(w, data)
+}
+`
+
+func TestGoRelations_TemplateFileDependencies(t *testing.T) {
+	tmpDir := t.TempDir()
+	f := filepath.Join(tmpDir, "handler.go")
+	require.NoError(t, os.WriteFile(f, []byte(goTemplateUsageCode), 0644))
+
+	ca := NewCodeAnalyzer()
+	res, err := ca.Analyze(context.Background(), tmpDir)
+	require.NoError(t, err)
+
+	renderPage := findGoSymbol(res.Symbols, "RenderPage")
+	require.NotNil(t, renderPage, "RenderPage function symbol must exist")
+
+	// Should have dependency relations to template file paths
+	assert.True(t, hasGoRelation(renderPage.Relations, "templates/layout.html", pkgParser.RelDependency),
+		"RenderPage should have dependency→templates/layout.html; got %v", renderPage.Relations)
+	assert.True(t, hasGoRelation(renderPage.Relations, "templates/header.html", pkgParser.RelDependency),
+		"RenderPage should have dependency→templates/header.html; got %v", renderPage.Relations)
+
+	// Should have template_files in metadata
+	if tplFiles, ok := renderPage.Metadata["template_files"]; ok {
+		files, ok := tplFiles.([]string)
+		assert.True(t, ok, "template_files metadata should be []string")
+		assert.Contains(t, files, "templates/layout.html")
+		assert.Contains(t, files, "templates/header.html")
+	} else {
+		t.Error("expected template_files metadata on RenderPage")
+	}
+
+	// RenderDashboard: ParseGlob with glob pattern
+	renderDash := findGoSymbol(res.Symbols, "RenderDashboard")
+	require.NotNil(t, renderDash, "RenderDashboard function symbol must exist")
+
+	assert.True(t, hasGoRelation(renderDash.Relations, "templates/dashboard/*.tmpl", pkgParser.RelDependency),
+		"RenderDashboard should have dependency→templates/dashboard/*.tmpl; got %v", renderDash.Relations)
+}

pkg/parser/go/types.go

@@ -51,6 +51,7 @@ type FunctionInfo struct {
 	EndLine     int          `json:"end_line,omitempty"`
 	Code        string       `json:"code,omitempty"`
 	Calls       []string     `json:"calls,omitempty"`
+	TemplateFiles []string   `json:"template_files,omitempty"` // Go template file paths from template.ParseFiles() etc.
 }
 
 // TypeInfo describes a type declaration (struct, interface, alias, etc.)

pkg/parser/html/analyzer.go

@@ -53,24 +53,26 @@ func (a *Analyzer) CanHandle(filePath string) bool {
 func (a *Analyzer) Analyze(ctx context.Context, path string) (*pkgParser.Result, error) {
 	var symbols []pkgParser.Symbol
 
-	// For single files: detect Go template syntax and run GoTemplate analysis
+	// Detect Go template syntax and run GoTemplate analysis
 	info, err := os.Stat(path)
 	if err != nil {
 		return nil, err
 	}
 
 	if !info.IsDir() {
-		data, err := os.ReadFile(path)
-		if err != nil {
-			return nil, err
-		}
-
-		// If Go template syntax detected, run Go template analysis first
-		if bytes.Contains(data, []byte("{{")) {
-			goTplAnalyzer := &gotemplate.GoTemplateAnalyzer{}
-			templates := goTplAnalyzer.Analyze([]string{path})
-			symbols = append(symbols, gotemplate.ConvertToSymbols(templates)...)
-		}
+		// Single file: check for Go template syntax
+		symbols = append(symbols, a.analyzeGoTemplates(path)...)
+	} else {
+		// Directory: walk and check each HTML file for Go template syntax
+		filepath.WalkDir(path, func(fp string, d fs.DirEntry, err error) error {
+			if err != nil || d.IsDir() {
+				return nil
+			}
+			if a.ca.isHTMLFile(d.Name()) {
+				symbols = append(symbols, a.analyzeGoTemplates(fp)...)
+			}
+			return nil
+		})
 	}
 
 	// Always run HTML DOM analysis too (Go templates contain HTML)
@@ -105,8 +107,19 @@ func (a *Analyzer) Analyze(ctx context.Context, path string) (*pkgParser.Result,
 	}, nil
 }
 
-
-
+// analyzeGoTemplates checks a single file for Go template syntax and returns symbols.
+func (a *Analyzer) analyzeGoTemplates(filePath string) []pkgParser.Symbol {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil
+	}
+	if !bytes.Contains(data, []byte("{{")) {
+		return nil
+	}
+	goTplAnalyzer := &gotemplate.GoTemplateAnalyzer{}
+	templates := goTplAnalyzer.Analyze([]string{filePath})
+	return gotemplate.ConvertToSymbols(templates)
+}
 // CodeAnalyzer handles the heavy lifting of HTML analysis.
 type CodeAnalyzer struct{}
 

pkg/parser/html/gotemplate/adapter.go

@@ -9,7 +9,9 @@ import (
 )
 
 // ConvertToSymbols converts parsed GoTemplate results to parser.Symbol entries
-// with structural relations (dependency for {{ template }}, inheritance-like for {{ block }}).
+// with structural relations:
+//   - RelDependency for {{ template "name" }} includes
+//   - RelInheritance for {{ block "name" }} (defines overridable default content)
 func ConvertToSymbols(templates []GoTemplate) []pkgParser.Symbol {
 	var symbols []pkgParser.Symbol
 
@@ -84,6 +86,13 @@ func buildFileSymbol(tpl GoTemplate, nameNoExt string) pkgParser.Symbol {
 			Type:       pkgParser.RelDependency,
 		})
 	}
+	// Build relations: blocks → inheritance (overridable default content)
+	for _, blk := range tpl.Blocks {
+		relations = append(relations, pkgParser.Relation{
+			TargetName: blk.Name,
+			Type:       pkgParser.RelInheritance,
+		})
+	}
 
 	endLine := tpl.TotalLines
 	if endLine < 1 {

pkg/parser/html/gotemplate/analyzer.go

@@ -3,19 +3,23 @@ package gotemplate
 import (
 	"bufio"
 	"os"
+	"path/filepath"
 	"regexp"
 	"strings"
+
+	"github.com/doITmagic/rag-code-mcp/internal/logger"
 )
 
 // Regex patterns for Go template directives.
 var (
 	reDefine   = regexp.MustCompile(`\{\{-?\s*define\s+"([^"]+)"\s*-?\}\}`)
-	reBlock    = regexp.MustCompile(`\{\{-?\s*block\s+"([^"]+)"\s*(\.[\w.]*)?`)
-	reTemplate = regexp.MustCompile(`\{\{-?\s*template\s+"([^"]+)"\s*(\.[\w.]*)?`)
-	reRange    = regexp.MustCompile(`\{\{-?\s*range\s+(\.[\w.]+)`)
+	reBlock    = regexp.MustCompile(`\{\{-?\s*block\s+"([^"]+)"\s*(\.[\w.]*)?\s*-?\}\}`)
+	reTemplate = regexp.MustCompile(`\{\{-?\s*template\s+"([^"]+)"\s*(\.[\w.]*)?\s*-?\}\}`)
+	reRange    = regexp.MustCompile(`\{\{-?\s*range\s+(\.[\w.]+)\s*-?\}\}`)
 	reIf       = regexp.MustCompile(`\{\{-?\s*if\s+(.+?)\s*-?\}\}`)
+	reElseIf   = regexp.MustCompile(`\{\{-?\s*else\s+if\s+(.+?)\s*-?\}\}`)
 	reElse     = regexp.MustCompile(`\{\{-?\s*else\s*-?\}\}`)
-	reWith     = regexp.MustCompile(`\{\{-?\s*with\s+(\.[\w.]+)`)
+	reWith     = regexp.MustCompile(`\{\{-?\s*with\s+(\.[\w.]+)\s*-?\}\}`)
 	reEnd      = regexp.MustCompile(`\{\{-?\s*end\s*-?\}\}`)
 	reComment  = regexp.MustCompile(`\{\{/\*.*?\*/\}\}`)
 	reVariable = regexp.MustCompile(`\{\{-?\s*(\.[\w.]+)\s*-?\}\}`)
@@ -43,7 +47,8 @@ func (a *GoTemplateAnalyzer) Analyze(filePaths []string) []GoTemplate {
 	for _, fp := range filePaths {
 		tpl, err := a.analyzeFile(fp)
 		if err != nil {
-			continue // skip unreadable files
+			logger.Instance.Debug("[GOTEMPLATE] skip %s: %v", filepath.Base(fp), err)
+			continue
 		}
 		templates = append(templates, tpl)
 	}
@@ -134,9 +139,23 @@ func (a *GoTemplateAnalyzer) analyzeFile(filePath string) (GoTemplate, error) {
 			stack = append(stack, openBlock{kind: "if", idx: len(tpl.Conditionals) - 1})
 		}
 
-		// {{ else }}
-		if reElse.MatchString(line) {
-			// Find the matching if on the stack
+		// {{ else if .Cond }} — must check BEFORE bare {{ else }}
+		if m := reElseIf.FindStringSubmatch(line); m != nil {
+			// Mark HasElse on the current if
+			for i := len(stack) - 1; i >= 0; i-- {
+				if stack[i].kind == "if" {
+					tpl.Conditionals[stack[i].idx].HasElse = true
+					break
+				}
+			}
+			// Push a new conditional for the else-if branch
+			tpl.Conditionals = append(tpl.Conditionals, ConditionalDirective{
+				Condition: strings.TrimSpace(m[1]),
+				Line:      lineNum,
+			})
+			stack = append(stack, openBlock{kind: "if", idx: len(tpl.Conditionals) - 1})
+		} else if reElse.MatchString(line) {
+			// {{ else }} — bare else without condition
 			for i := len(stack) - 1; i >= 0; i-- {
 				if stack[i].kind == "if" {
 					tpl.Conditionals[stack[i].idx].HasElse = true
@@ -191,6 +210,10 @@ func (a *GoTemplateAnalyzer) analyzeFile(filePath string) (GoTemplate, error) {
 		}
 	}
 
+	if err := scanner.Err(); err != nil {
+		return GoTemplate{}, err
+	}
+
 	tpl.TotalLines = lineNum
 	return tpl, nil
 }