igel-qe-core 1.0.0

package/knowledge_base/agents/kg_agent.py

@@ -0,0 +1,91 @@
+"""Knowledge graph agent — enriches retrieval_agent KG context (no duplicate fetch)."""
+from __future__ import annotations
+
+import re
+import time
+
+from knowledge_base.agents.state import AgenticState
+from knowledge_base.config import cfg
+from knowledge_base.db.client import get_conn
+
+
+def kg_agent(state: AgenticState) -> AgenticState:
+    t0 = time.perf_counter()
+    query = state.get("query", "")
+    kg_block = state.get("kg_context_block") or ""
+
+    try:
+        text = kg_block
+        keys = re.findall(r"\b(app\.[a-z0-9]+(?:\.[a-z0-9_]+)+)\b", text, re.I)
+        paths = re.findall(r"TC\s*Setup[^•\n]{5,120}", text, re.I)
+
+        verified_keys = []
+        for k in dict.fromkeys(keys)[:30]:
+            status = "confirmed" if _kg_has_entity("registry_key", k) else "unverified"
+            verified_keys.append({"key": k, "confidence": status})
+
+        related_tcs, related_defects = _fetch_related_entities(query)
+
+        state["kg_entities"] = {
+            "registry_keys": verified_keys,
+            "ui_paths": [{"path": p.strip(), "confidence": "confirmed"} for p in dict.fromkeys(paths)[:20]],
+            "related_testcases": related_tcs,
+            "related_defects": related_defects,
+            "feature_relationships": [],
+            "backend": cfg.KG_BACKEND,
+        }
+        status = "complete"
+    except Exception as e:
+        state["kg_entities"] = {}
+        status = "error"
+        state.setdefault("agent_trace", []).append({
+            "agent": "KGAgent", "status": "error", "reason": str(e),
+        })
+        return state
+
+    ents = len(state["kg_entities"].get("registry_keys", [])) + len(state["kg_entities"].get("ui_paths", []))
+    state.setdefault("agent_trace", []).append({
+        "agent": "KGAgent",
+        "status": status,
+        "backend": cfg.KG_BACKEND,
+        "entities_found": ents,
+        "timing_ms": round((time.perf_counter() - t0) * 1000, 1),
+    })
+    return state
+
+
+def _kg_has_entity(node_type: str, value: str) -> bool:
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(
+                "SELECT 1 FROM knowledge_graph_nodes WHERE node_type=%s AND normalized=%s LIMIT 1",
+                (node_type, value.lower()[:2000]),
+            )
+            return cur.fetchone() is not None
+
+
+def _fetch_related_entities(query: str) -> tuple[list, list]:
+    tcs: list[dict] = []
+    defects: list[dict] = []
+    tokens = [t for t in re.findall(r"\w{4,}", query.lower())[:5]]
+    if not tokens:
+        return tcs, defects
+    pattern = "%" + "%".join(tokens[:2]) + "%"
+    with get_conn() as conn:
+        with conn.cursor() as cur:
+            cur.execute(
+                """
+                SELECT node_type, value FROM knowledge_graph_nodes
+                WHERE node_type IN ('testcase', 'defect', 'error_code')
+                  AND (normalized ILIKE %s OR value ILIKE %s)
+                LIMIT 10
+                """,
+                (pattern, pattern),
+            )
+            for node_type, value in cur.fetchall():
+                item = {"id": value, "title": value}
+                if node_type == "testcase":
+                    tcs.append(item)
+                else:
+                    defects.append(item)
+    return tcs, defects

package/knowledge_base/agents/memory_agent.py

@@ -0,0 +1,62 @@
+"""Memory agent — Phase 4/5 Cognee search."""
+from __future__ import annotations
+
+from knowledge_base.agents.state import AgenticState
+from knowledge_base.config import cfg
+from knowledge_base.memory.cognee_client import get_cognee_client
+from knowledge_base.memory.memory_types import MemoryType
+
+
+def memory_agent(state: AgenticState) -> AgenticState:
+    if not cfg.COGNEE_ENABLED:
+        state["memory_context"] = []
+        state.setdefault("agent_trace", []).append({
+            "agent": "MemoryAgent", "status": "skipped", "reason": "COGNEE_ENABLED=false",
+        })
+        return state
+
+    query = state.get("query", "")
+    feature = state.get("feature_area", "Unknown")
+    categories = state.get("query_categories", [])
+
+    try:
+        client = get_cognee_client()
+        types = [MemoryType.FEEDBACK.value, MemoryType.PATTERN.value]
+        if "troubleshooting" in categories or "regression" in categories:
+            types.append(MemoryType.EXECUTION.value)
+
+        results = client.search(
+            query=f"{feature} {query}",
+            memory_types=types,
+            feature_area=feature,
+            top_k=5,
+            min_relevance=0.5,
+        )
+        state["memory_context"] = [
+            {
+                "memory_id": m.memory_id,
+                "memory_type": m.memory_type.value,
+                "content": m.content,
+                "feature_area": m.feature_area,
+                "relevance_score": m.relevance_score,
+                "applied_at": m.applied_at,
+                "curator": m.curator,
+            }
+            for m in results
+            if m.feature_area == feature or feature == "Unknown"
+        ]
+        status = "complete"
+    except Exception as e:
+        state["memory_context"] = []
+        status = "error"
+        state.setdefault("agent_trace", []).append({
+            "agent": "MemoryAgent", "status": "error", "reason": str(e),
+        })
+        return state
+
+    state.setdefault("agent_trace", []).append({
+        "agent": "MemoryAgent",
+        "status": status,
+        "memories_retrieved": len(state["memory_context"]),
+    })
+    return state

package/knowledge_base/agents/rca_agent.py

@@ -0,0 +1,53 @@
+"""RCA agent — Phase 7."""
+from __future__ import annotations
+
+from knowledge_base.config import cfg
+from knowledge_base.graph_db.kg_traversal import traverse_failure_path
+from knowledge_base.memory.cognee_client import get_cognee_client
+from knowledge_base.memory.memory_types import MemoryType
+
+
+def analyze_failure(test_id: str, failure_log: str) -> dict:
+    """Traverse KG + memory to find root cause chain."""
+    if cfg.KG_BACKEND == "neo4j":
+        chain_result = traverse_failure_path(test_id)
+    else:
+        chain_result = {"status": "insufficient_graph_data", "chain": [], "missing": ["neo4j_primary"]}
+
+    similar = []
+    if cfg.COGNEE_ENABLED:
+        client = get_cognee_client()
+        memories = client.search(
+            query=f"{test_id} {failure_log[:200]}",
+            memory_types=[MemoryType.EXECUTION.value],
+            top_k=3,
+        )
+        similar = [{"content": m.content, "score": m.relevance_score} for m in memories]
+
+    if chain_result.get("status") == "insufficient_graph_data" and not similar:
+        return {
+            "status": "insufficient_graph_data",
+            "root_cause_chain": [],
+            "similar_failures": [],
+            "missing": chain_result.get("missing", []),
+            "confidence": 0.2,
+        }
+
+    summary = _build_summary(chain_result, similar, failure_log)
+    return {
+        "status": "complete",
+        "test_id": test_id,
+        "root_cause_chain": chain_result.get("root_cause_chain") or chain_result.get("chain", []),
+        "similar_failures": similar,
+        "suggested_fix": summary,
+        "confidence": 0.7 if chain_result.get("root_cause_chain") else 0.4,
+    }
+
+
+def _build_summary(chain_result: dict, similar: list, failure_log: str) -> str:
+    chain = chain_result.get("root_cause_chain") or chain_result.get("chain") or []
+    if chain:
+        return f"Failure path: {' → '.join(str(c) for c in chain[:6])}"
+    if similar:
+        return f"Similar past failure pattern: {similar[0]['content'][:200]}"
+    return f"Analyze failure log manually: {failure_log[:300]}"

package/knowledge_base/agents/reflection_agent.py

@@ -0,0 +1,62 @@
+"""Reflection agent — Phase 5."""
+from __future__ import annotations
+
+from knowledge_base.agents.state import AgenticState
+
+
+def reflection_agent(state: AgenticState) -> AgenticState:
+    fused = state.get("fused_context") or {}
+    categories = state.get("query_categories", [])
+    version = state.get("version_scope", "unspecified")
+    temporal = state.get("temporal_context") or {}
+    intent = state.get("intent", "synthesize")
+    rag = state.get("rag_chunks", [])
+
+    notes: list[str] = []
+    procedure_steps = fused.get("procedure_steps") or []
+
+    if not fused.get("registry_keys") and "configuration" in categories:
+        notes.append("no_registry_keys")
+    if not fused.get("ui_paths"):
+        notes.append("no_ui_paths")
+    if len(procedure_steps) < 3:
+        notes.append("no_procedure_steps")
+    if version == "unspecified" and "version_specific" in categories:
+        notes.append("version_unconfirmed")
+    if version != "unspecified" and temporal.get("status") == "skipped":
+        notes.append("no_temporal_context")
+    if intent == "synthesize" and "negative_case" not in categories:
+        if not any("fail" in s.lower() or "error" in s.lower() for s in procedure_steps):
+            notes.append("no_negative_case_material")
+    if fused.get("context_quality", 0) < 0.5:
+        notes.append("low_context_quality")
+    if len(fused.get("conflicts") or []) > 2:
+        notes.append("unresolved_conflicts")
+
+    count = state.get("reflection_count", 0) + 1
+    state["reflection_count"] = count
+
+    if count >= 2:
+        state["force_to_validation"] = True
+        state["reflection_notes"] = []
+        state.setdefault("agent_trace", []).append({
+            "agent": "ReflectionAgent",
+            "status": "max_loops_reached",
+            "forced_to_validation": True,
+        })
+    else:
+        state["force_to_validation"] = False
+        state["reflection_notes"] = notes
+        state.setdefault("agent_trace", []).append({
+            "agent": "ReflectionAgent",
+            "status": "complete",
+            "reflection_notes": notes,
+            "loop": count,
+        })
+    return state
+
+
+def should_loop_back(state: AgenticState) -> bool:
+    if state.get("force_to_validation"):
+        return False
+    return bool(state.get("reflection_notes"))

package/knowledge_base/agents/regression_agent.py

@@ -0,0 +1,81 @@
+import logging
+from typing import List, Dict, Any, Set
+from pathlib import Path
+from knowledge_base.db.client import get_conn
+from knowledge_base.agents.code_intelligence_agent import CodeIntelligenceAgent
+
+logger = logging.getLogger(__name__)
+
+class BitbucketSyncAgent:
+    """Agent responsible for performing Delta Syncs from Bitbucket."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        self.code_agent = CodeIntelligenceAgent(repo_path)
+        
+    def sync_changed_files(self, changed_files: List[Path]) -> int:
+        """Only index the specifically changed files (Delta Sync)."""
+        indexed = 0
+        for file in changed_files:
+            if not file.exists():
+                logger.info(f"File {file} deleted, removing from registry.")
+                rel_path = str(file.relative_to(self.repo_path))
+                with get_conn() as conn:
+                    with conn.cursor() as cur:
+                        cur.execute("DELETE FROM igel_asset_registry WHERE file_path = %s", (rel_path,))
+                    conn.commit()
+            else:
+                indexed += self.code_agent.index_file(file)
+                
+        return indexed
+
+class RegressionAgent:
+    """Agent responsible for determining impact of code changes."""
+    
+    def analyze_impact(self, changed_files: List[Path], repo_path: Path) -> Dict[str, Any]:
+        """Find requirements, test cases, and scripts affected by the changed files."""
+        impact = {
+            "affected_requirements": set(),
+            "affected_scripts": set(),
+            "affected_assets": set()
+        }
+        
+        try:
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    for file in changed_files:
+                        rel_path = str(file.relative_to(repo_path))
+                        
+                        # 1. Find all assets in this file
+                        cur.execute("SELECT id, name FROM igel_asset_registry WHERE file_path = %s", (rel_path,))
+                        assets = cur.fetchall()
+                        for asset_id, asset_name in assets:
+                            impact["affected_assets"].add(asset_name)
+                            
+                            # 2. Find all requirements mapped to this asset
+                            cur.execute(
+                                """
+                                SELECT r.jira_key 
+                                FROM igel_requirements r
+                                JOIN igel_asset_mappings m ON r.id = m.requirement_id
+                                WHERE m.asset_id = %s
+                                """, 
+                                (asset_id,)
+                            )
+                            for req_row in cur.fetchall():
+                                impact["affected_requirements"].add(req_row[0])
+                                
+                        # 3. Find if this file itself is an automation script
+                        cur.execute("SELECT script_path FROM igel_automation_scripts WHERE script_path = %s", (rel_path,))
+                        if cur.fetchone():
+                            impact["affected_scripts"].add(rel_path)
+                            
+        except Exception as e:
+            logger.error(f"Failed to analyze impact: {e}")
+            
+        # Convert sets to lists for JSON serialization
+        return {
+            "affected_requirements": list(impact["affected_requirements"]),
+            "affected_scripts": list(impact["affected_scripts"]),
+            "affected_assets": list(impact["affected_assets"])
+        }

package/knowledge_base/agents/requirement_agent.py

@@ -0,0 +1,71 @@
+import json
+import logging
+from typing import Dict, Any
+from openai import AzureOpenAI
+from knowledge_base.config import cfg
+from knowledge_base.models.test_requirement import RequirementUnderstanding, TestRequirement
+
+logger = logging.getLogger(__name__)
+
+_SYSTEM_PROMPT = """You are an expert IGEL Quality Engineering Architect.
+Your task is to analyze a raw Jira/Xray Test Requirement and extract critical domain understanding.
+You must extract actors, entities, explicit business rules, validations, constraints, and dependencies.
+Output MUST be valid JSON matching this schema:
+{
+  "actors": ["string"],
+  "entities": ["string"],
+  "business_rules": ["string"],
+  "validations": ["string"],
+  "constraints": ["string"],
+  "dependencies": ["string"]
+}
+"""
+
+_llm_client: AzureOpenAI | None = None
+
+def _get_llm_client() -> AzureOpenAI:
+    global _llm_client
+    if _llm_client is None:
+        _llm_client = AzureOpenAI(
+            api_key=cfg.AZURE_API_KEY,
+            azure_endpoint=cfg.AZURE_ENDPOINT,
+            api_version=cfg.AZURE_API_VERSION,
+        )
+    return _llm_client
+
+def extract_understanding(requirement: TestRequirement) -> RequirementUnderstanding:
+    """Analyze a requirement and extract its core semantic understanding."""
+    client = _get_llm_client()
+    
+    user_prompt = f"Requirement Key: {requirement.jira_key}\nSummary: {requirement.summary}\nDescription: {requirement.description or 'None'}\n"
+    
+    try:
+        response = client.chat.completions.create(
+            model=cfg.AZURE_DEPLOYMENT,
+            messages=[
+                {"role": "system", "content": _SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            response_format={"type": "json_object"},
+            temperature=0.1,
+            max_tokens=1500,
+        )
+        
+        content = response.choices[0].message.content or "{}"
+        data = json.loads(content)
+        
+        understanding = RequirementUnderstanding(
+            actors=data.get("actors", []),
+            entities=data.get("entities", []),
+            business_rules=data.get("business_rules", []),
+            validations=data.get("validations", []),
+            constraints=data.get("constraints", []),
+            dependencies=data.get("dependencies", [])
+        )
+        logger.info(f"Successfully extracted understanding for {requirement.jira_key}")
+        return understanding
+        
+    except Exception as e:
+        logger.error(f"Failed to extract understanding for {requirement.jira_key}: {e}")
+        # Return empty understanding on failure to not block the pipeline
+        return RequirementUnderstanding()

package/knowledge_base/agents/retrieval_agent.py

@@ -0,0 +1,66 @@
+"""Retrieval agent — Phase 5 (RAG + EKG + Web + MCP)."""
+from __future__ import annotations
+
+from knowledge_base.agents.state import AgenticState
+from knowledge_base.retrieval.unified_query import unified_query
+
+
+def retrieval_agent(state: AgenticState) -> AgenticState:
+    query = state.get("query", "")
+    top_k = state.get("top_k", 8)
+    product = state.get("product")
+
+    try:
+        uq = unified_query(query=query, top_k=top_k, product=product)
+        bundle = uq.rag
+        chunks = []
+        for r in bundle.results:
+            chunks.append({
+                "chunk_id": r.child_chunk_id,
+                "content": r.parent_content,
+                "source_type": (r.metadata.get("source_type") if r.metadata else None) or "igel_docs",
+                "source_name": r.file_name,
+                "version_tag": None,
+                "rrf_score": r.rrf_score,
+                "rerank_score": r.rerank_score,
+            })
+        state["rag_chunks"] = chunks
+        state["web_context"] = {
+            "block": uq.web_block,
+            "hits": [
+                {"url": h.url, "title": h.title, "source_type": h.source_type, "score": h.score}
+                for h in uq.web_hits
+            ],
+        }
+        state["mcp_context"] = {
+            "block": uq.mcp.block,
+            "hits": [
+                {"source": h.source, "title": h.title, "url": h.url, "score": h.score}
+                for h in uq.mcp.hits
+            ],
+            "sources_queried": uq.mcp.sources_queried,
+        }
+        state["sources_summary"] = uq.sources_summary
+        state["kg_context_block"] = bundle.kg_context.text_block
+        status = "complete" if chunks else "no_results"
+        top_score = chunks[0]["rrf_score"] if chunks else 0
+    except Exception as e:
+        state["rag_chunks"] = []
+        state["web_context"] = {"block": "", "hits": []}
+        state["mcp_context"] = {"block": "", "hits": [], "sources_queried": []}
+        status = "error"
+        top_score = 0
+        state.setdefault("agent_trace", []).append({
+            "agent": "RetrievalAgent", "status": "error", "reason": str(e),
+        })
+        return state
+
+    state.setdefault("agent_trace", []).append({
+        "agent": "RetrievalAgent",
+        "status": status,
+        "chunks_retrieved": len(state["rag_chunks"]),
+        "web_hits": len(state["web_context"]["hits"]),
+        "mcp_hits": len(state["mcp_context"]["hits"]),
+        "top_score": top_score,
+    })
+    return state

package/knowledge_base/agents/scenario_agent.py

@@ -0,0 +1,81 @@
+import json
+import logging
+from typing import List, Dict, Any
+from openai import AzureOpenAI
+from knowledge_base.config import cfg
+from knowledge_base.models.test_requirement import (
+    TestRequirement, 
+    TestStep, 
+    BusinessRule, 
+    ScenarioWithRules
+)
+from knowledge_base.agents.requirement_agent import _get_llm_client
+
+logger = logging.getLogger(__name__)
+
+_SYSTEM_PROMPT = """You are an expert IGEL Quality Engineering Architect.
+Your task is to take a specific Scenario (a test step from a Jira requirement) and generate an exhaustive list of Business Rules for it.
+Business rules dictate exactly what MUST be tested (positive, negative, and edge cases).
+Consider the requirement's overall understanding context when generating rules.
+Output MUST be valid JSON matching this schema:
+{
+  "business_rules": [
+    {
+      "rule_type": "positive" | "negative" | "edge",
+      "description": "string"
+    }
+  ]
+}
+"""
+
+def generate_business_rules(requirement: TestRequirement, step: TestStep) -> ScenarioWithRules:
+    """Analyze a scenario (test step) and extract exhaustive business rules."""
+    client = _get_llm_client()
+    
+    # Construct context from the requirement's understanding if available
+    context_str = ""
+    if requirement.understanding:
+        context_str = f"Context (Actors): {', '.join(requirement.understanding.actors)}\n"
+        context_str += f"Context (Entities): {', '.join(requirement.understanding.entities)}\n"
+        context_str += f"Context (Constraints): {', '.join(requirement.understanding.constraints)}\n"
+        
+    user_prompt = f"Requirement: {requirement.summary}\n{context_str}\n"
+    user_prompt += f"Scenario (Step {step.step_number}):\nAction: {step.action}\nData: {step.test_data or 'N/A'}\nExpected: {step.expected_result or 'N/A'}\n"
+    user_prompt += "\nGenerate exhaustive business rules for this scenario."
+
+    try:
+        response = client.chat.completions.create(
+            model=cfg.AZURE_DEPLOYMENT,
+            messages=[
+                {"role": "system", "content": _SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            response_format={"type": "json_object"},
+            temperature=0.2,
+            max_tokens=2000,
+        )
+        
+        content = response.choices[0].message.content or "{}"
+        data = json.loads(content)
+        
+        rules = []
+        for r in data.get("business_rules", []):
+            if isinstance(r, dict) and "rule_type" in r and "description" in r:
+                rules.append(BusinessRule(
+                    rule_type=r["rule_type"],
+                    description=r["description"]
+                ))
+                
+        logger.info(f"Generated {len(rules)} business rules for step {step.step_number}")
+        return ScenarioWithRules(scenario=step, business_rules=rules)
+        
+    except Exception as e:
+        logger.error(f"Failed to generate business rules for step {step.step_number}: {e}")
+        return ScenarioWithRules(scenario=step, business_rules=[])
+
+def generate_all_scenarios(requirement: TestRequirement) -> List[ScenarioWithRules]:
+    """Process all steps in a requirement to generate comprehensive business rules."""
+    scenarios = []
+    for step in requirement.steps:
+        scenarios.append(generate_business_rules(requirement, step))
+    return scenarios