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

- Laravel: walk UP parent directories looking for artisan / composer.json with laravel/framework
- WordPress: walk UP parent directories looking for wp-config.php, wp-content, plugin/theme headers
- Add detection caching (laravelCache, wordpressCache) to avoid repeated stat calls
- Replace all fmt.Fprintf(os.Stderr) with logger.Instance.{Debug,Info,Warn,Error}
- Add detailed enrichment pipeline logging (chunks before/after, route files, etc.)
- Bump version to 2.1.86

Author: razvan

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,26 @@ 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
+	wordpressCache 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),
+		wordpressCache: make(map[string]bool),
 	}
 }
 
@@ -79,12 +86,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 +143,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 +1205,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 +1221,58 @@ 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
+}
+
+// isLaravelByFilesystem walks up from filePath checking for Laravel root indicators.
+// Results are cached per directory to avoid repeated stat calls.
+func (ca *CodeAnalyzer) isLaravelByFilesystem(filePath string) bool {
+	dir := filepath.Dir(filePath)
+	for {
+		if result, ok := ca.laravelCache[dir]; ok {
+			return result
+		}
+
+		// Check for artisan (the strongest Laravel indicator)
+		if _, err := os.Stat(filepath.Join(dir, "artisan")); err == nil {
+			ca.laravelCache[dir] = 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
+				return true
+			}
+		}
+
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break // reached filesystem root
+		}
+		dir = parent
+	}
+	ca.laravelCache[dir] = 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,101 @@ func init() {
 	})
 }
 
-// IsApplicable checks if the parsed paths correspond to a Laravel project
+// IsApplicable checks if the parsed paths correspond to a Laravel project.
 func (e *Enricher) IsApplicable(ca *php.CodeAnalyzer, paths []string) bool {
-	return ca.IsLaravelProject()
+	// 1. Quick: namespace/class-based detection from already-parsed packages
+	byPackages := ca.IsLaravelProject()
+	logger.Instance.Debug("[LARAVEL] IsApplicable: ca.IsLaravelProject()=%v for paths=%v", byPackages, paths)
+	if byPackages {
+		return true
+	}
+
+	// 2. Filesystem walk-up
+	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
+}
+
+// isLaravelRoot walks UP from dir checking each parent for Laravel indicators.
+func isLaravelRoot(dir string) bool {
+	for {
+		// 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.Info("[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.Info("[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.Info("[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.Info("[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.Info("[LARAVEL] Enrich DONE: returning %d total chunks", len(chunks))
 	return chunks
 }

pkg/parser/php/laravel/migrations.go

@@ -1,7 +1,6 @@
 package laravel
 
 import (
-	"fmt"
 	"os"
 	"strings"
 
@@ -12,6 +11,8 @@ import (
 	"github.com/VKCOM/php-parser/pkg/version"
 	"github.com/VKCOM/php-parser/pkg/visitor"
 	"github.com/VKCOM/php-parser/pkg/visitor/traverser"
+
+	"github.com/doITmagic/rag-code-mcp/internal/logger"
 )
 
 // MigrationAnalyzer parses Laravel migration files
@@ -33,7 +34,7 @@ func (ma *MigrationAnalyzer) Analyze(filePaths []string) ([]Migration, error) {
 	for _, path := range filePaths {
 		migrations, err := ma.analyzeFile(path)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error analyzing migration file %s: %v\n", path, err)
+			logger.Instance.Warn("[LARAVEL] Error analyzing migration file %s: %v", path, err)
 			continue
 		}
 		allMigrations = append(allMigrations, migrations...)

pkg/parser/php/laravel/routes.go

@@ -12,6 +12,8 @@ import (
 	"github.com/VKCOM/php-parser/pkg/version"
 	"github.com/VKCOM/php-parser/pkg/visitor"
 	"github.com/VKCOM/php-parser/pkg/visitor/traverser"
+
+	"github.com/doITmagic/rag-code-mcp/internal/logger"
 )
 
 // RouteAnalyzer parses Laravel route files
@@ -34,7 +36,7 @@ func (ra *RouteAnalyzer) Analyze(filePaths []string) ([]Route, error) {
 		routes, err := ra.analyzeFile(path)
 		if err != nil {
 			// Log error but continue
-			fmt.Fprintf(os.Stderr, "Error analyzing route file %s: %v\n", path, err)
+			logger.Instance.Warn("[LARAVEL] Error analyzing route file %s: %v", path, err)
 			continue
 		}
 		allRoutes = append(allRoutes, routes...)

pkg/parser/php/php_analyzer.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/doITmagic/rag-code-mcp/internal/logger"
 	pkgParser "github.com/doITmagic/rag-code-mcp/pkg/parser"
 )
 
@@ -21,6 +22,7 @@ var enrichers []FrameworkEnricher
 // RegisterEnricher adds a framework-specific enricher to the PHP parser.
 func RegisterEnricher(e FrameworkEnricher) {
 	enrichers = append(enrichers, e)
+	logger.Instance.Info("[PHP-ENRICHER] Registered enricher #%d: %T", len(enrichers), e)
 }
 
 func init() {
@@ -52,26 +54,36 @@ func (a *Analyzer) CanHandle(filePath string) bool {
 // Analyze extracts symbols from a file or directory.
 func (a *Analyzer) Analyze(ctx context.Context, path string) (*pkgParser.Result, error) {
 	paths := []string{path}
+	logger.Instance.Debug("[PHP] Analyze: %s (enrichers=%d)", filepath.Base(path), len(enrichers))
+
 	chunks, err := a.codeAnalyzer.AnalyzePaths(paths)
 	if err != nil {
+		logger.Instance.Error("[PHP] Analyze ERROR: %s: %v", filepath.Base(path), err)
 		return nil, err
 	}
+	logger.Instance.Debug("[PHP] Analyze: %s → %d base chunks, %d packages", filepath.Base(path), len(chunks), len(a.codeAnalyzer.GetPackages()))
 
 	// Fetch packages analyzed by the core PHP parser
 	packages := a.codeAnalyzer.GetPackages()
 
 	// Run all registered framework enrichers
-	for _, enricher := range enrichers {
-		if enricher.IsApplicable(a.codeAnalyzer, paths) {
+	for i, enricher := range enrichers {
+		applicable := enricher.IsApplicable(a.codeAnalyzer, paths)
+		logger.Instance.Debug("[PHP] Enricher #%d (%T) IsApplicable=%v for %s", i, enricher, applicable, filepath.Base(path))
+		if applicable {
+			before := len(chunks)
 			chunks = enricher.Enrich(a.codeAnalyzer, packages, paths, chunks)
+			logger.Instance.Info("[PHP] Enricher #%d (%T) enriched: %d → %d chunks for %s", i, enricher, before, len(chunks), filepath.Base(path))
 		}
 	}
 
 	// If no symbols found and the file is in a routes/ directory,
 	// try extracting Route::* calls as symbols (Laravel convention).
 	if len(chunks) == 0 && isRouteFile(path) {
+		logger.Instance.Info("[PHP] Route fallback for %s", filepath.Base(path))
 		routeChunks := a.codeAnalyzer.ExtractRouteChunks(path)
 		chunks = append(chunks, routeChunks...)
+		logger.Instance.Info("[PHP] Route fallback: +%d chunks", len(routeChunks))
 	}
 
 	symbols := make([]pkgParser.Symbol, len(chunks))