feat(php): add filesystem walk-up detection for Laravel & WordPress + structured logging

Implements parent-directory walk-up framework detection for deeply nested PHP files:

Laravel detection:
- Walk UP parent dirs looking for `artisan` or `composer.json` with `laravel/framework`
- Results cached per starting directory via `laravelCache` on CodeAnalyzer
- maxWalkUpDepth=10 prevents unbounded traversal

WordPress detection:
- Walk UP parent dirs looking for `wp-config.php`, `wp-content`, `wp-includes`, `wp-admin`
- Plugin/theme header detection reads only first 4KB (`readFilePrefix`)
- maxWalkUpDepth=10 prevents unbounded traversal

Structured logging:
- Replaced all `fmt.Fprintf(os.Stderr, ...)` with `logger.Instance.{Debug,Info,Warn,Error}`
- Per-file enrichment logs set to Debug to avoid log flooding during indexing
- Startup/registration logs remain at Info level

Review fixes (PR #44 Copilot review - all 10 comments addressed):
- Added maxDepth limit to both WP and Laravel walk-up functions
- Limited file reads to 4KB prefix for header detection
- Fixed isLaravelByFilesystem caching (cache starting dir, not just root)
- Removed unused `wordpressCache` field from CodeAnalyzer
- Added 16 unit tests (8 WordPress + 8 Laravel filesystem walk-up)

Version bump: 2.1.86

Author: doITmagic

cmd/rag-code-mcp/main.go

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

pkg/parser/php/analyzer.go

@@ -15,19 +15,24 @@ import (
 	"github.com/VKCOM/php-parser/pkg/visitor"
 	"github.com/VKCOM/php-parser/pkg/visitor/traverser"
 
+	"github.com/doITmagic/rag-code-mcp/internal/logger"
 	pkgParser "github.com/doITmagic/rag-code-mcp/pkg/parser"
 )
 
 // CodeAnalyzer implements PathAnalyzer for PHP
 type CodeAnalyzer struct {
 	currentNamespace string
 	packages         map[string]*PackageInfo
+
+	// Cached framework detection results (per directory → result)
+	laravelCache map[string]bool
 }
 
 // NewCodeAnalyzer creates a new PHP code analyzer
 func NewCodeAnalyzer() *CodeAnalyzer {
 	return &CodeAnalyzer{
-		packages: make(map[string]*PackageInfo),
+		packages:     make(map[string]*PackageInfo),
+		laravelCache: make(map[string]bool),
 	}
 }
 
@@ -79,12 +84,12 @@ func (ca *CodeAnalyzer) AnalyzePaths(paths []string) ([]CodeChunk, error) {
 
 				content, err := os.ReadFile(path)
 				if err != nil {
-					fmt.Fprintf(os.Stderr, "Warning: failed to read %s: %v\n", path, err)
+					logger.Instance.Warn("[PHP] failed to read %s: %v", path, err)
 					return nil
 				}
 
 				if err := ca.parseAndCollect(path, content); err != nil {
-					fmt.Fprintf(os.Stderr, "Warning: failed to analyze %s: %v\n", path, err)
+					logger.Instance.Warn("[PHP] failed to analyze %s: %v", path, err)
 				}
 				return nil
 			})
@@ -136,13 +141,13 @@ func (ca *CodeAnalyzer) parseAndCollect(filePath string, content []byte) error {
 	if len(parserErrors) > 0 {
 		// Only log first few errors to avoid spam
 		maxErrors := 3
-		fmt.Fprintf(os.Stderr, "PHP parser warnings in %s:\n", filePath)
+		logger.Instance.Debug("[PHP] parser warnings in %s:", filePath)
 		for i, e := range parserErrors {
 			if i >= maxErrors {
-				fmt.Fprintf(os.Stderr, "  ... and %d more\n", len(parserErrors)-maxErrors)
+				logger.Instance.Debug("[PHP]   ... and %d more", len(parserErrors)-maxErrors)
 				break
 			}
-			fmt.Fprintf(os.Stderr, "  %s\n", e.String())
+			logger.Instance.Debug("[PHP]   %s", e.String())
 		}
 	}
 
@@ -1198,15 +1203,13 @@ func (v *symbolCollector) walkExpr(expr ast.Vertex, calls *[]MethodCall) {
 
 // IsLaravelProject detects if the analyzed code is from a Laravel project
 func (ca *CodeAnalyzer) IsLaravelProject() bool {
+	// 1. Quick check: namespace/class-based detection from parsed packages
 	for _, pkg := range ca.packages {
-		// Check for Laravel-specific namespaces
 		if strings.HasPrefix(pkg.Namespace, "App\\Models") ||
 			strings.HasPrefix(pkg.Namespace, "App\\Http\\Controllers") ||
 			strings.HasPrefix(pkg.Namespace, "Illuminate\\") {
 			return true
 		}
-
-		// Check for Laravel base classes
 		for _, class := range pkg.Classes {
 			if class.Extends == "Model" ||
 				class.Extends == "Controller" ||
@@ -1216,6 +1219,72 @@ func (ca *CodeAnalyzer) IsLaravelProject() bool {
 			}
 		}
 	}
+
+	// 2. Filesystem walk-up: check for "artisan" file by walking parent dirs
+	for _, pkg := range ca.packages {
+		for _, class := range pkg.Classes {
+			if class.FilePath != "" {
+				if ca.isLaravelByFilesystem(class.FilePath) {
+					return true
+				}
+			}
+		}
+		for _, fn := range pkg.Functions {
+			if fn.FilePath != "" {
+				if ca.isLaravelByFilesystem(fn.FilePath) {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+// maxLaravelWalkUpDepth limits how many parent directories the walk-up detection traverses.
+const maxLaravelWalkUpDepth = 10
+
+// isLaravelByFilesystem walks up from filePath checking for Laravel root indicators.
+// Results are cached per starting directory to avoid repeated stat calls.
+func (ca *CodeAnalyzer) isLaravelByFilesystem(filePath string) bool {
+	startDir := filepath.Dir(filePath)
+	// Check cache for the starting directory first
+	if result, ok := ca.laravelCache[startDir]; ok {
+		return result
+	}
+
+	dir := startDir
+	for depth := 0; depth < maxLaravelWalkUpDepth; depth++ {
+		// Check cache for this specific directory
+		if result, ok := ca.laravelCache[dir]; ok {
+			// Cache the result for the starting directory as well
+			ca.laravelCache[startDir] = result
+			return result
+		}
+
+		// Check for artisan (the strongest Laravel indicator)
+		if _, err := os.Stat(filepath.Join(dir, "artisan")); err == nil {
+			ca.laravelCache[dir] = true
+			ca.laravelCache[startDir] = true
+			return true
+		}
+
+		// Also check for composer.json with laravel/framework
+		composerPath := filepath.Join(dir, "composer.json")
+		if content, err := os.ReadFile(composerPath); err == nil {
+			if strings.Contains(string(content), "laravel/framework") {
+				ca.laravelCache[dir] = true
+				ca.laravelCache[startDir] = true
+				return true
+			}
+		}
+
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break // reached filesystem root
+		}
+		dir = parent
+	}
+	ca.laravelCache[startDir] = false
 	return false
 }
 

pkg/parser/php/laravel/enricher.go

@@ -1,6 +1,11 @@
 package laravel
 
 import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/doITmagic/rag-code-mcp/internal/logger"
 	"github.com/doITmagic/rag-code-mcp/pkg/parser/php"
 )
 
@@ -15,32 +20,109 @@ func init() {
 	})
 }
 
-// IsApplicable checks if the parsed paths correspond to a Laravel project
+// IsApplicable checks if the parsed paths correspond to a Laravel project.
+// ca.IsLaravelProject() already includes both namespace/class-based AND filesystem walk-up detection,
+// so we only need to call it once. If packages are empty (no classes/functions parsed),
+// fall back to direct path-based filesystem walk-up.
 func (e *Enricher) IsApplicable(ca *php.CodeAnalyzer, paths []string) bool {
-	return ca.IsLaravelProject()
+	// 1. namespace/class-based + cached filesystem walk from parsed packages
+	byPackages := ca.IsLaravelProject()
+	logger.Instance.Debug("[LARAVEL] IsApplicable: ca.IsLaravelProject()=%v for paths=%v", byPackages, paths)
+	if byPackages {
+		return true
+	}
+
+	// 2. Fallback: direct path-based filesystem walk (useful when no packages were parsed)
+	byFS := IsLaravelProjectByPaths(paths)
+	logger.Instance.Debug("[LARAVEL] IsApplicable: IsLaravelProjectByPaths()=%v for paths=%v", byFS, paths)
+	return byFS
+}
+
+// IsLaravelProjectByPaths walks UP parent directories from the given paths
+// looking for Laravel root indicators (artisan file, composer.json with laravel/framework).
+func IsLaravelProjectByPaths(paths []string) bool {
+	for _, p := range paths {
+		dir := p
+		info, err := os.Stat(p)
+		if err != nil {
+			logger.Instance.Debug("[LARAVEL] IsLaravelProjectByPaths: stat error for %s: %v", p, err)
+			continue
+		}
+		if !info.IsDir() {
+			dir = filepath.Dir(p)
+		}
+
+		if isLaravelRoot(dir) {
+			logger.Instance.Debug("[LARAVEL] IsLaravelProjectByPaths: FOUND Laravel root walking up from %s", dir)
+			return true
+		}
+		logger.Instance.Debug("[LARAVEL] IsLaravelProjectByPaths: NO Laravel root found walking up from %s", dir)
+	}
+	return false
+}
+
+// maxWalkUpDepth limits how many parent directories the walk-up detection traverses.
+// This prevents scanning unrelated parts of the host filesystem for deeply nested paths.
+const maxWalkUpDepth = 10
+
+// isLaravelRoot walks UP from dir checking each parent for Laravel indicators.
+// Stops after maxWalkUpDepth levels to avoid traversing unrelated directories.
+func isLaravelRoot(dir string) bool {
+	for depth := 0; depth < maxWalkUpDepth; depth++ {
+		// Check for artisan (the strongest Laravel indicator)
+		artisanPath := filepath.Join(dir, "artisan")
+		if _, err := os.Stat(artisanPath); err == nil {
+			logger.Instance.Debug("[LARAVEL] isLaravelRoot: FOUND artisan at %s", artisanPath)
+			return true
+		}
+
+		// Check for composer.json with laravel/framework
+		composerPath := filepath.Join(dir, "composer.json")
+		if content, err := os.ReadFile(composerPath); err == nil {
+			if strings.Contains(string(content), "laravel/framework") {
+				logger.Instance.Debug("[LARAVEL] isLaravelRoot: FOUND laravel/framework in %s", composerPath)
+				return true
+			}
+		}
+
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break // reached filesystem root
+		}
+		dir = parent
+	}
+	return false
 }
 
 // Enrich receives the base PHP chunks and analyzed packages and returns chunks merged with Laravel specifics
 func (e *Enricher) Enrich(ca *php.CodeAnalyzer, packages []*php.PackageInfo, paths []string, chunks []php.CodeChunk) []php.CodeChunk {
+	logger.Instance.Debug("[LARAVEL] Enrich: %d packages, %d paths, %d existing chunks", len(packages), len(paths), len(chunks))
+
 	// Run Laravel-specific package analysis for Controllers and Eloquent Models
 	for _, pkg := range packages {
 		analyzer := NewAnalyzer(pkg)
 		info := analyzer.Analyze()
+		logger.Instance.Debug("[LARAVEL] Enrich pkg=%s: models=%d controllers=%d", pkg.Namespace, len(info.Models), len(info.Controllers))
 
 		// Enrich existing chunks with Laravel context (table, fillable, api routes)
 		e.adapter.enrichChunks(chunks, info)
 	}
 
-	// Analyze Routes (these are handled separately since they are mostly top level closures inside routes/)
+	// Analyze Routes
 	routeFiles := e.adapter.findRouteFiles(paths)
+	logger.Instance.Debug("[LARAVEL] Enrich: found %d route files from paths=%v", len(routeFiles), paths)
 	if len(routeFiles) > 0 {
 		routeAnalyzer := NewRouteAnalyzer()
 		routes, err := routeAnalyzer.Analyze(routeFiles)
 		if err == nil {
 			routeChunks := e.adapter.convertRoutesToChunks(routes)
+			logger.Instance.Debug("[LARAVEL] Enrich: %d routes → %d chunks", len(routes), len(routeChunks))
 			chunks = append(chunks, routeChunks...)
+		} else {
+			logger.Instance.Error("[LARAVEL] Enrich: route analysis error: %v", err)
 		}
 	}
 
+	logger.Instance.Debug("[LARAVEL] Enrich DONE: returning %d total chunks", len(chunks))
 	return chunks
 }