feat: integrate Oxygen and WooCommerce analyzers into WordPress pipeline

razvan · razvan · commit 059ffee39237 · 2026-03-16T22:08:54.000+02:00
- Add OxygenInfo and WooCommerceInfo fields to WordPressInfo struct
- Add oxygen.Analyzer and woocommerce.Analyzer to WordPress Analyzer
- Call Oxygen analyzer in analyzeWordPress() for OxyEl element detection
- Call WooCommerce analyzer for hook classification by area (cart, checkout, product, etc.)
- Convert Oxygen elements/templates and WC hooks/API calls to CodeChunks
- Break import cycle: woocommerce package no longer imports wordpress
  - Define WPHookInput in woocommerce as local mirror of WPHook
  - Reimplement AST helpers locally in woocommerce package
- Add integration tests:
  - TestAnalyzer_OxygenElementDetection (end-to-end OxyEl detection)
  - TestAnalyzer_WooCommerceHookClassification (end-to-end WC area classification)
  - TestConvertToChunks_OxygenAndWooCommerce (nil safety)
diff --git a/.gitignore b/.gitignore
@@ -60,6 +60,7 @@ Thumbs.db
 # Temporary files
 tmp/
 temp/
+docs/plans/*.md
 
 # Scripts
 scripts/
diff --git a/pkg/parser/php/wordpress/analyzer.go b/pkg/parser/php/wordpress/analyzer.go
@@ -15,6 +15,8 @@ import (
 
 	pkgParser "github.com/doITmagic/rag-code-mcp/pkg/parser"
 	"github.com/doITmagic/rag-code-mcp/pkg/parser/php"
+	"github.com/doITmagic/rag-code-mcp/pkg/parser/php/wordpress/oxygen"
+	"github.com/doITmagic/rag-code-mcp/pkg/parser/php/wordpress/woocommerce"
 )
 
 // Analyzer is the main WordPress framework analyzer that coordinates all WordPress-specific analyzers
@@ -26,6 +28,8 @@ type Analyzer struct {
 	widgetAnalyzer       *WidgetAnalyzer
 	adminAnalyzer        *AdminAnalyzer
 	pluginHeaderAnalyzer *PluginHeaderAnalyzer
+	oxygenAnalyzer       *oxygen.Analyzer
+	woocommerceAnalyzer  *woocommerce.Analyzer
 	phpAnalyzer          *php.CodeAnalyzer
 }
 
@@ -39,6 +43,8 @@ func NewAnalyzer() *Analyzer {
 		widgetAnalyzer:       NewWidgetAnalyzer(),
 		adminAnalyzer:        NewAdminAnalyzer(),
 		pluginHeaderAnalyzer: NewPluginHeaderAnalyzer(),
+		oxygenAnalyzer:       oxygen.NewAnalyzer(),
+		woocommerceAnalyzer:  woocommerce.NewAnalyzer(),
 		phpAnalyzer:          php.NewCodeAnalyzer(),
 	}
 }
@@ -147,6 +153,31 @@ func (a *Analyzer) analyzeWordPress(packages []*php.PackageInfo, paths []string)
 		})
 	}
 
+	// Oxygen Builder analysis (reuses already-parsed packages)
+	oxyInfo := a.oxygenAnalyzer.AnalyzeFromPackages(packages)
+	if oxyInfo != nil && (len(oxyInfo.Elements) > 0 || len(oxyInfo.Templates) > 0) {
+		info.OxygenInfo = oxyInfo
+	}
+
+	// WooCommerce analysis: classify WP hooks that have woocommerce_ prefix
+	var wcInputHooks []woocommerce.WPHookInput
+	for _, h := range info.Hooks {
+		wcInputHooks = append(wcInputHooks, woocommerce.WPHookInput{
+			Type:      string(h.Type),
+			Name:      h.Name,
+			Callback:  h.Callback,
+			Priority:  h.Priority,
+			FilePath:  h.FilePath,
+			StartLine: h.StartLine,
+			EndLine:   h.EndLine,
+		})
+	}
+	wcHooks := a.woocommerceAnalyzer.AnalyzeHooksFromWP(wcInputHooks)
+	if len(wcHooks) > 0 {
+		wcInfo := &woocommerce.WooCommerceInfo{Hooks: wcHooks}
+		info.WooCommerceInfo = wcInfo
+	}
+
 	return info
 }
 
@@ -344,6 +375,92 @@ func (a *Analyzer) convertToChunks(info *WordPressInfo) []php.CodeChunk {
 		})
 	}
 
+	// Convert Oxygen elements
+	if info.OxygenInfo != nil {
+		if oxyInfo, ok := info.OxygenInfo.(*oxygen.OxygenInfo); ok {
+			for _, elem := range oxyInfo.Elements {
+				chunks = append(chunks, php.CodeChunk{
+					Name:      elem.ClassName,
+					Type:      "oxy_element",
+					Language:  "php",
+					FilePath:  elem.FilePath,
+					StartLine: elem.StartLine,
+					EndLine:   elem.EndLine,
+					Signature: fmt.Sprintf("class %s extends OxyEl", elem.ClassName),
+					Docstring: fmt.Sprintf("Oxygen Builder Element: %s (methods: %s)", elem.ClassName, strings.Join(elem.Methods, ", ")),
+					Metadata: map[string]any{
+						"framework": "wordpress",
+						"wp_type":   "oxygen_element",
+						"namespace": elem.Namespace,
+						"has_slug":  elem.SlugMethod,
+						"methods":   elem.Methods,
+					},
+				})
+			}
+
+			for _, tmpl := range oxyInfo.Templates {
+				chunks = append(chunks, php.CodeChunk{
+					Name:      tmpl.PostType,
+					Type:      "oxy_template",
+					Language:  "php",
+					FilePath:  tmpl.FilePath,
+					StartLine: tmpl.Line,
+					EndLine:   tmpl.Line,
+					Signature: fmt.Sprintf("register_post_type('%s', ...)", tmpl.PostType),
+					Docstring: fmt.Sprintf("Oxygen Template: %s", tmpl.PostType),
+					Metadata: map[string]any{
+						"framework": "wordpress",
+						"wp_type":   "oxygen_template",
+					},
+				})
+			}
+		}
+	}
+
+	// Convert WooCommerce hooks
+	if info.WooCommerceInfo != nil {
+		if wcInfo, ok := info.WooCommerceInfo.(*woocommerce.WooCommerceInfo); ok {
+			for _, wcHook := range wcInfo.Hooks {
+				chunks = append(chunks, php.CodeChunk{
+					Name:      wcHook.HookName,
+					Type:      "wc_hook",
+					Language:  "php",
+					FilePath:  wcHook.FilePath,
+					StartLine: wcHook.StartLine,
+					EndLine:   wcHook.EndLine,
+					Signature: fmt.Sprintf("%s('%s', '%s')", wcHook.HookType, wcHook.HookName, wcHook.Callback),
+					Docstring: fmt.Sprintf("WooCommerce %s hook (%s area): %s", wcHook.HookType, wcHook.Area, wcHook.HookName),
+					Metadata: map[string]any{
+						"framework": "wordpress",
+						"wp_type":   "wc_hook",
+						"wc_area":   string(wcHook.Area),
+						"hook_type": wcHook.HookType,
+						"callback":  wcHook.Callback,
+						"priority":  wcHook.Priority,
+					},
+				})
+			}
+
+			for _, apiCall := range wcInfo.APICalls {
+				chunks = append(chunks, php.CodeChunk{
+					Name:      apiCall.Function,
+					Type:      "wc_api_call",
+					Language:  "php",
+					FilePath:  apiCall.FilePath,
+					StartLine: apiCall.StartLine,
+					EndLine:   apiCall.EndLine,
+					Signature: fmt.Sprintf("%s(...)", apiCall.Function),
+					Docstring: fmt.Sprintf("WooCommerce API call: %s (category: %s)", apiCall.Function, apiCall.Category),
+					Metadata: map[string]any{
+						"framework":   "wordpress",
+						"wp_type":     "wc_api_call",
+						"wc_category": apiCall.Category,
+					},
+				})
+			}
+		}
+	}
+
 	return chunks
 }
 
diff --git a/pkg/parser/php/wordpress/analyzer_test.go b/pkg/parser/php/wordpress/analyzer_test.go
@@ -385,3 +385,138 @@ func TestMergePostTypes_Deduplication(t *testing.T) {
 		t.Errorf("expected 2 post types after merge, got %d", len(result))
 	}
 }
+
+func TestAnalyzer_OxygenElementDetection(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// Plugin header to detect as WordPress
+	err := os.WriteFile(filepath.Join(tmpDir, "plugin.php"), []byte(`<?php
+/**
+ * Plugin Name: Oxygen Custom Elements
+ */
+`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Oxygen element extending OxyEl
+	oxyFile := filepath.Join(tmpDir, "elements.php")
+	err = os.WriteFile(oxyFile, []byte(`<?php
+class MyCustomHeader extends OxyEl {
+    public function slug() {
+        return 'my-custom-header';
+    }
+    public function render($options, $defaults, $content) {
+        echo '<h1>Custom</h1>';
+    }
+}
+`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	analyzer := NewAnalyzer()
+	chunks, err := analyzer.AnalyzePaths([]string{tmpDir})
+	if err != nil {
+		t.Fatalf("AnalyzePaths failed: %v", err)
+	}
+
+	// Find oxy_element chunks
+	var oxyChunks []string
+	for _, c := range chunks {
+		if c.Type == "oxy_element" {
+			oxyChunks = append(oxyChunks, c.Name)
+			if c.Metadata["framework"] != "wordpress" {
+				t.Errorf("Oxygen chunk %s: expected framework=wordpress", c.Name)
+			}
+			if c.Metadata["wp_type"] != "oxygen_element" {
+				t.Errorf("Oxygen chunk %s: expected wp_type=oxygen_element, got %v", c.Name, c.Metadata["wp_type"])
+			}
+		}
+	}
+
+	if len(oxyChunks) == 0 {
+		t.Error("expected at least 1 oxy_element chunk, got 0")
+	} else {
+		t.Logf("Found Oxygen elements: %v", oxyChunks)
+	}
+}
+
+func TestAnalyzer_WooCommerceHookClassification(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// Plugin header
+	err := os.WriteFile(filepath.Join(tmpDir, "plugin.php"), []byte(`<?php
+/**
+ * Plugin Name: WooCommerce Extension
+ */
+`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// WC hooks
+	wcFile := filepath.Join(tmpDir, "wc-hooks.php")
+	err = os.WriteFile(wcFile, []byte(`<?php
+add_action('woocommerce_before_cart', 'custom_cart_notice');
+add_filter('woocommerce_product_get_price', 'custom_price', 10, 2);
+add_action('woocommerce_checkout_process', 'validate_checkout');
+`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	analyzer := NewAnalyzer()
+	chunks, err := analyzer.AnalyzePaths([]string{tmpDir})
+	if err != nil {
+		t.Fatalf("AnalyzePaths failed: %v", err)
+	}
+
+	// Find wc_hook chunks
+	wcAreas := make(map[string]bool)
+	for _, c := range chunks {
+		if c.Type == "wc_hook" {
+			area, _ := c.Metadata["wc_area"].(string)
+			wcAreas[area] = true
+			if c.Metadata["framework"] != "wordpress" {
+				t.Errorf("WC chunk %s: expected framework=wordpress", c.Name)
+			}
+		}
+	}
+
+	if len(wcAreas) == 0 {
+		t.Error("expected WC hook chunks, got 0")
+	}
+	if !wcAreas["cart"] {
+		t.Error("expected wc_area=cart for woocommerce_before_cart")
+	}
+	if !wcAreas["product"] {
+		t.Error("expected wc_area=product for woocommerce_product_get_price")
+	}
+	if !wcAreas["checkout"] {
+		t.Error("expected wc_area=checkout for woocommerce_checkout_process")
+	}
+
+	t.Logf("Found WC areas: %v", wcAreas)
+}
+
+func TestConvertToChunks_OxygenAndWooCommerce(t *testing.T) {
+	analyzer := NewAnalyzer()
+
+	// Use concrete types for OxygenInfo and WooCommerceInfo
+	info := &WordPressInfo{
+		Hooks: []WPHook{
+			{Type: HookAction, Name: "init", Callback: "my_init", FilePath: "test.php", StartLine: 1, EndLine: 1},
+		},
+	}
+
+	// Test that convertToChunks handles nil OxygenInfo/WooCommerceInfo gracefully
+	chunks := analyzer.convertToChunks(info)
+	if len(chunks) != 1 {
+		t.Fatalf("expected 1 chunk (hook), got %d", len(chunks))
+	}
+	if chunks[0].Type != "wp_hook" {
+		t.Errorf("expected wp_hook, got %s", chunks[0].Type)
+	}
+}
+
diff --git a/pkg/parser/php/wordpress/types.go b/pkg/parser/php/wordpress/types.go
@@ -2,16 +2,18 @@ package wordpress
 
 // WordPressInfo contains WordPress-specific framework information extracted from a project
 type WordPressInfo struct {
-	Hooks         []WPHook       `json:"hooks,omitempty"`
-	PostTypes     []PostType     `json:"post_types,omitempty"`
-	Taxonomies    []Taxonomy     `json:"taxonomies,omitempty"`
-	Shortcodes    []Shortcode    `json:"shortcodes,omitempty"`
-	Blocks        []Block        `json:"blocks,omitempty"`
-	BlockPatterns []BlockPattern `json:"block_patterns,omitempty"`
-	Widgets       []Widget       `json:"widgets,omitempty"`
-	AdminPages    []AdminPage    `json:"admin_pages,omitempty"`
-	Settings      []Setting      `json:"settings,omitempty"`
-	PluginHeader  *PluginHeader  `json:"plugin_header,omitempty"`
+	Hooks           []WPHook       `json:"hooks,omitempty"`
+	PostTypes       []PostType     `json:"post_types,omitempty"`
+	Taxonomies      []Taxonomy     `json:"taxonomies,omitempty"`
+	Shortcodes      []Shortcode    `json:"shortcodes,omitempty"`
+	Blocks          []Block        `json:"blocks,omitempty"`
+	BlockPatterns   []BlockPattern `json:"block_patterns,omitempty"`
+	Widgets         []Widget       `json:"widgets,omitempty"`
+	AdminPages      []AdminPage    `json:"admin_pages,omitempty"`
+	Settings        []Setting      `json:"settings,omitempty"`
+	PluginHeader    *PluginHeader  `json:"plugin_header,omitempty"`
+	OxygenInfo      any            `json:"oxygen,omitempty"`      // *oxygen.OxygenInfo (avoid import cycle)
+	WooCommerceInfo any            `json:"woocommerce,omitempty"` // *woocommerce.WooCommerceInfo (avoid import cycle)
 }
 
 // HookType represents the type of a WordPress hook
diff --git a/pkg/parser/php/wordpress/woocommerce/analyzer.go b/pkg/parser/php/wordpress/woocommerce/analyzer.go
diff --git a/pkg/parser/php/wordpress/woocommerce/analyzer_test.go b/pkg/parser/php/wordpress/woocommerce/analyzer_test.go
