Final changes

Author: avimallick

AntiPattern_Remediator/src/core/agents/explainer.py

@@ -1,15 +1,16 @@
 """
 ExplainerAgent — minimal version
 - Delegates state handling to create_graph.py
-- Only builds messages and parses JSON response
-- Keeps code minimal and focused
+- Uses PromptManager if available; otherwise a tiny inline fallback prompt
+- Always passes msgs; always returns a non-empty explanation_json
 """
 from __future__ import annotations
 
 from typing import Dict, Any
 import json
 
 from langchain_core.language_models import BaseLanguageModel
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
 from ..prompt import PromptManager
 from src.core.utils import extract_first_json
 
@@ -32,33 +33,55 @@ def explain_antipattern(self, state: Dict[str, Any]) -> Dict[str, Any]:
             antipattern_name=state.get("antipattern_name", "Unknown antipattern"),
             antipattern_description=state.get("antipattern_description", ""),
             antipatterns_json=json.dumps(state.get("antipatterns_json", []), ensure_ascii=False),
+            msgs=state.get("msgs", []),  # ensure MessagesPlaceholder is satisfied
         )
 
         messages = self._build_messages(**kwargs)
-        response = self.llm.invoke(messages)
-        raw = getattr(response, "content", None) or str(response)
+
+        try:
+            response = self.llm.invoke(messages)
+            raw = getattr(response, "content", None) or str(response)
+        except Exception as e:
+            raw = f"LLM error: {e}"
+
         state["explanation_response_raw"] = raw
 
-        parsed = extract_first_json(raw)
-        state["explanation_json"] = parsed if isinstance(parsed, dict) else {}
+        # Robust parse: accept dict, wrap list, or emit a minimal fallback
+        try:
+            parsed = extract_first_json(raw)
+        except Exception:
+            parsed = None
+
+        if isinstance(parsed, dict):
+            state["explanation_json"] = parsed
+        elif isinstance(parsed, list):
+            state["explanation_json"] = {"items": parsed}
+        else:
+            state["explanation_json"] = self._fallback_payload(state)
+
         return state
 
     def display_explanation(self, state: Dict[str, Any]) -> Dict[str, Any]:
         print("\n=== Explanation (raw) ===\n", state.get("explanation_response_raw", "N/A"))
         if state.get("explanation_json"):
-            print("\n=== Explanation (JSON) ===\n", json.dumps(state["explanation_json"], indent=2, ensure_ascii=False))
+            print("\n=== Explanation (JSON) ===\n",
+                  json.dumps(state["explanation_json"], indent=2, ensure_ascii=False))
         return state
 
     def _build_messages(self, **kwargs) -> Any:
-        try:
-            getp = getattr(self.prompt_manager, "get_prompt", None)
-            if callable(getp):
-                prompt = getp(PROMPT_KEY)
-                if prompt is not None:
-                    return prompt.format_messages(**kwargs)
-        except Exception:
-            pass
+        # Always ensure msgs exists
+        if "msgs" not in kwargs or kwargs["msgs"] is None:
+            kwargs = {**kwargs, "msgs": []}
 
+        # 1) Try preloaded template from PromptManager
+        prompt = None
+        getp = getattr(self.prompt_manager, "get_prompt", None)
+        if callable(getp):
+            prompt = getp(PROMPT_KEY)
+        if prompt is not None:
+            return prompt.format_messages(**kwargs)
+
+        # 2) Minimal inline fallback
         schema = {
             "items": [{
                 "antipattern_name": "",
@@ -76,11 +99,33 @@ def _build_messages(self, **kwargs) -> Any:
             "closing_summary": ""
         }
         content = (
-            "Given inputs (JSON):\n" + json.dumps(kwargs, ensure_ascii=False) +
+            "Given inputs (JSON):\n" + json.dumps({k: v for k, v in kwargs.items() if k != "msgs"}, ensure_ascii=False) +
             "\nRespond with STRICT JSON using exactly this schema:\n" +
             json.dumps(schema, ensure_ascii=False)
         )
-        return [
-            {"role": "system", "content": "Return STRICT JSON only. No commentary."},
-            {"role": "user", "content": content},
-        ]
+        fallback = ChatPromptTemplate.from_messages([
+            ("system", "Return STRICT JSON only. No commentary."),
+            ("user", content),
+            MessagesPlaceholder("msgs"),
+        ])
+        return fallback.format_messages(**kwargs)
+
+    @staticmethod
+    def _fallback_payload(state: Dict[str, Any]) -> Dict[str, Any]:
+        """Tiny fallback so downstream never breaks if parsing fails."""
+        return {
+            "items": [{
+                "antipattern_name": state.get("antipattern_name", "Unknown antipattern"),
+                "antipattern_description": state.get("antipattern_description", ""),
+                "impact": "",
+                "why_it_is_bad": "",
+                "how_we_fixed_it": state.get("refactor_rationale", ""),
+                "refactored_code": state.get("refactored_code", ""),
+                "summary": "Auto-generated minimal explanation (parser fallback)."
+            }],
+            "what_changed": [],
+            "why_better": [],
+            "principles_applied": [],
+            "trade_offs": [],
+            "closing_summary": ""
+        }

AntiPattern_Remediator/src/core/state.py

@@ -8,6 +8,7 @@
 class AgentState(TypedDict):
     """State definition for passing data through the workflow"""
     code: str                                # Code to be analyzed
+    language: Optional[str]                  # Language of the code (used by ExplainerAgent)
     context: Optional[str]                   # Context retrieved from knowledge base (scanner)
     trove_context: Optional[str]             # Context retrieved from the Anti-Pattern Trove (TinyDB/Chroma)
     antipatterns_scanner_results: Optional[str]
@@ -20,3 +21,6 @@ class AgentState(TypedDict):
     explanation_response_raw: Optional[str]  # Raw LLM output from explainer
     explanation_json: Optional[Dict[str, Any]]  # Parsed JSON explanation
     current_file_path: Optional[str]         # Path to the current file being processed
+
+    explanation_response_raw: Optional[str]      # Raw LLM output from explainer
+    explanation_json: Optional[Dict[str, Any]]   # Parsed JSON explanation

AntiPattern_Remediator/static/prompt/explainer.yaml

@@ -1,9 +1,8 @@
 explainer:
-  template: |
-    You are a senior software reviewer. 
-    Your job is to explain detected anti-patterns and the applied refactor in a clear, structured way. 
-    Output STRICT JSON only — no commentary outside JSON.
+  system: |
+    You are a senior software reviewer. Output STRICT JSON only — no commentary outside the JSON object.
 
+  user: |
     === Inputs ===
     Language: {language}
     Context: {context}
@@ -15,28 +14,28 @@ explainer:
     Refactor Rationale:
     {refactor_rationale}
 
-    === Required Output Schema ===
-    {
+    === Return EXACTLY this JSON structure ===
+    {{
       "items": [
-        {
+        {{
           "antipattern_name": "",
           "antipattern_description": "",
           "impact": "",
           "why_it_is_bad": "",
           "how_we_fixed_it": "",
           "refactored_code": "",
           "summary": ""
-        }
+        }}
       ],
       "what_changed": [],
       "why_better": [],
       "principles_applied": [],
       "trade_offs": [],
       "closing_summary": ""
-    }
+    }}
 
-    Notes:
-    - Always return valid JSON.
-    - Use multiple entries under "items" if more than one antipattern is relevant.
-    - Keep `refactored_code` short (or truncated if needed).
-    - Fill all fields, even if briefly.
+    Rules:
+    - Return valid JSON only (no code fences, no prose).
+    - If multiple antipatterns apply, include multiple entries in "items".
+    - Keep "refactored_code" concise; truncate if needed but keep it valid.
+    - Populate all fields; use brief placeholders if unsure.

AntiPattern_Remediator/test/unit_test/prompt/test_prompt_manager.py

@@ -583,7 +583,7 @@ def temp_prompt_files(self):
                 },
                 'explainer.yaml': {
                     'explainer': {
-                        'system': 'You are a senior software reviewer.',
+                        'system': 'You are a senior software code explainer.',
                         'user': 'Explain: {code}\nLang: {language}\nCtx: {context}'
                     }
                 }