igel-qe-core 1.0.5 → 1.0.8

package/knowledge_base/agents/confidence_agent.py

@@ -1,95 +0,0 @@
-import logging
-from knowledge_base.models.test_requirement import (
-    GeneratedTestCase, 
-    ScenarioWithRules,
-    ConfidenceMetrics,
-    TestCaseWithConfidence
-)
-
-logger = logging.getLogger(__name__)
-
-def evaluate_coverage(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
-    """Calculate if the test cases cover the business rules.
-    If we are evaluating a single TC, we see if it represents its rule properly.
-    Here we return 1.0 if it maps to a rule, 0.0 otherwise.
-    """
-    if any(r.description == tc.business_rule.description for r in scenario.business_rules):
-        return 1.0
-    return 0.0
-
-def evaluate_traceability(tc: GeneratedTestCase) -> float:
-    """Check if the test case is traceable to a specific step."""
-    return 1.0 if "S" in tc.tc_reference and tc.business_rule else 0.0
-
-def evaluate_completeness(tc: GeneratedTestCase) -> float:
-    """Evaluate completeness of steps, data, and expected results."""
-    if not tc.steps:
-        return 0.0
-    
-    score = 0.0
-    for step in tc.steps:
-        step_score = 0.0
-        if step.action: step_score += 0.4
-        if step.data: step_score += 0.2
-        if step.expected_result: step_score += 0.4
-        score += step_score
-        
-    return score / len(tc.steps)
-
-def evaluate_automation_feasibility(tc: GeneratedTestCase) -> float:
-    """
-    Evaluate if this test case can be automated based on the Asset Registry.
-    For now, return a placeholder high score unless we have specific constraints.
-    (This will be enhanced when the Code Intelligence Agent is fully integrated).
-    """
-    return 0.9
-
-def compute_hybrid_confidence(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> TestCaseWithConfidence:
-    """
-    Compute the deterministic hybrid confidence score.
-    Weights:
-    - Coverage: 25%
-    - Traceability: 20%
-    - Completeness: 20%
-    - Historical Similarity: 15% (Stubbed to 0.8 for now)
-    - Automation Feasibility: 20%
-    """
-    coverage = evaluate_coverage(tc, scenario)
-    traceability = evaluate_traceability(tc)
-    completeness = evaluate_completeness(tc)
-    historical_similarity = 0.8 # Placeholder for vector DB search against approved tests
-    automation_feasibility = evaluate_automation_feasibility(tc)
-    
-    total = (
-        coverage * 0.25 +
-        traceability * 0.20 +
-        completeness * 0.20 +
-        historical_similarity * 0.15 +
-        automation_feasibility * 0.20
-    )
-    
-    metrics = ConfidenceMetrics(
-        coverage_score=coverage,
-        traceability_score=traceability,
-        completeness_score=completeness,
-        historical_similarity_score=historical_similarity,
-        automation_feasibility_score=automation_feasibility,
-        total_score=total
-    )
-    
-    tc.confidence_score = total
-    # Support both Pydantic v1 (.dict()) and v2 (.model_dump())
-    tc.confidence_metrics = metrics.model_dump() if hasattr(metrics, 'model_dump') else metrics.dict()
-    
-    is_approved = total >= 0.80
-    
-    if not is_approved:
-        logger.info(f"Test case {tc.tc_reference} needs review (score: {total:.2f})")
-    else:
-        logger.info(f"Test case {tc.tc_reference} auto-approved (score: {total:.2f})")
-        
-    return TestCaseWithConfidence(
-        test_case=tc,
-        confidence=metrics,
-        is_approved=is_approved
-    )

package/knowledge_base/agents/execution_validation_agent.py

@@ -1,129 +0,0 @@
-import ast
-import logging
-import subprocess
-from pathlib import Path
-from typing import Tuple, List, Set
-
-from knowledge_base.db.client import get_conn
-
-logger = logging.getLogger(__name__)
-
-class ExecutionValidationAgent:
-    """Multi-stage validation pipeline for generated automation scripts."""
-    
-    def __init__(self, repo_path: Path):
-        self.repo_path = repo_path
-        
-    def validate_syntax(self, code: str) -> Tuple[bool, str]:
-        """Stage 1: Check Python syntax."""
-        try:
-            ast.parse(code)
-            return True, ""
-        except SyntaxError as e:
-            return False, f"SyntaxError at line {e.lineno}: {e.msg}"
-            
-    def _get_known_assets(self, asset_type: str) -> Set[str]:
-        """Fetch all known assets of a specific type from the Asset Registry."""
-        assets = set()
-        try:
-            with get_conn() as conn:
-                with conn.cursor() as cur:
-                    cur.execute("SELECT name FROM igel_asset_registry WHERE asset_type = %s", (asset_type,))
-                    for row in cur.fetchall():
-                        assets.add(row[0])
-        except Exception as e:
-            logger.error(f"Failed to query registry for {asset_type}: {e}")
-        return assets
-
-    def validate_imports(self, code: str) -> Tuple[bool, str]:
-        """Stage 2: Check if imported modules exist in the registry."""
-        try:
-            tree = ast.parse(code)
-        except SyntaxError:
-            return False, "Syntax invalid, cannot check imports."
-            
-        # For simplicity, we just extract 'from module import X' and check X
-        # A more robust check would analyze the actual repo path.
-        missing_imports = []
-        known_pos = self._get_known_assets("page_object")
-        known_utils = self._get_known_assets("utility")
-        known_clients = self._get_known_assets("api_client")
-        
-        all_known = known_pos | known_utils | known_clients
-        
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ImportFrom):
-                for name in node.names:
-                    # Ignore standard library and common 3rd party (pytest, allure, typing, etc.)
-                    if node.module and not any(node.module.startswith(p) for p in ["pytest", "allure", "typing", "selenium", "playwright", "os", "json", "time"]):
-                        # This is a naive check; in a real enterprise system, you'd match the import path to `file_path`
-                        pass
-        return True, ""
-        
-    def validate_fixtures(self, code: str) -> Tuple[bool, str]:
-        """Stage 3: Check if requested pytest fixtures exist."""
-        try:
-            tree = ast.parse(code)
-        except SyntaxError:
-            return False, "Syntax invalid, cannot check fixtures."
-            
-        known_fixtures = self._get_known_assets("fixture")
-        
-        missing = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.FunctionDef) and node.name.startswith("test_"):
-                # pytest uses argument names to request fixtures
-                for arg in node.args.args:
-                    arg_name = arg.arg
-                    # Ignore common built-in fixtures
-                    if arg_name not in ["request", "monkeypatch", "capsys", "tmpdir", "self", "cls"]:
-                        if known_fixtures and arg_name not in known_fixtures:
-                            missing.append(f"Fixture '{arg_name}' requested by {node.name} not found in registry.")
-                            
-        if missing:
-            return False, "\n".join(missing)
-        return True, ""
-        
-    def validate_pytest_collection(self, file_path: Path) -> Tuple[bool, str]:
-        """Stage 4: Perform a pytest dry-run (collection only)."""
-        if not file_path.exists():
-            return False, f"File {file_path} does not exist."
-            
-        # Run pytest --collect-only
-        try:
-            # Note: Requires pytest to be installed in the environment running the server
-            result = subprocess.run(
-                ["pytest", "--collect-only", str(file_path)],
-                capture_output=True,
-                text=True,
-                cwd=str(self.repo_path)
-            )
-            
-            if result.returncode != 0:
-                # 5 means no tests collected, which is also an error for us
-                if result.returncode == 5:
-                    return False, "Pytest collected 0 tests."
-                return False, f"Pytest collection failed:\n{result.stderr or result.stdout}"
-                
-            return True, ""
-        except Exception as e:
-            return False, f"Error running pytest collection: {e}"
-            
-    def validate_pipeline(self, code: str, file_path: Path) -> Tuple[bool, str, str]:
-        """Run all execution validation stages."""
-        logger.info(f"Starting execution validation pipeline for {file_path}")
-        
-        ok, err = self.validate_syntax(code)
-        if not ok: return False, "syntax_failed", err
-        
-        ok, err = self.validate_imports(code)
-        if not ok: return False, "import_failed", err
-        
-        ok, err = self.validate_fixtures(code)
-        if not ok: return False, "fixture_failed", err
-        
-        ok, err = self.validate_pytest_collection(file_path)
-        if not ok: return False, "collection_failed", err
-        
-        logger.info(f"Execution validation passed for {file_path}")
-        return True, "passed", ""

package/knowledge_base/agents/intent_agent.py

@@ -1,76 +0,0 @@
-"""Intent classification agent — Phase 5."""
-from __future__ import annotations
-
-import re
-
-from knowledge_base.agents.state import AgenticState
-
-_FEATURE_MAP = {
-    "entra": "Entra ID SSO",
-    "sso": "Entra ID SSO",
-    "mfa": "Entra ID MFA",
-    "wifi": "Network WiFi 802.1x",
-    "802.1": "Network WiFi 802.1x",
-    "icg": "ICG Certificate Management",
-    "certificate": "ICG Certificate Management",
-    "chromium": "Chromium Browser",
-    "ums": "UMS Administration",
-    "profile": "UMS Profile Assignment",
-    "amd": "AMD Driver Integration",
-    "hub": "Device Onboarding IGEL Hub",
-}
-
-_VERSIONS = ("12.8", "12.9", "12.10")
-
-
-def intent_agent(state: AgenticState) -> AgenticState:
-    query = state.get("query", "")
-    q_lower = query.lower()
-
-    if any(w in q_lower for w in ("transform", "restructure", "reformat", "improve this")):
-        intent = "transform"
-    elif any(w in q_lower for w in ("expand", "add detail", "step-by-step")):
-        intent = "expand"
-    else:
-        intent = "synthesize"
-
-    feature = "Unknown"
-    for kw, name in _FEATURE_MAP.items():
-        if kw in q_lower:
-            feature = name
-            break
-
-    version_scope = "unspecified"
-    categories: list[str] = []
-    for v in _VERSIONS:
-        if v in query or f"os {v}" in q_lower:
-            version_scope = v
-            categories.append("version_specific")
-            break
-    if version_scope == "unspecified":
-        categories.append("version_unspecified")
-
-    if any(w in q_lower for w in ("fail", "error", "negative", "boundary")):
-        categories.append("negative_case")
-    if any(w in q_lower for w in ("regression", "release", "change impact")):
-        categories.append("regression")
-    if any(w in q_lower for w in ("debug", "troubleshoot", "root cause")):
-        categories.append("troubleshooting")
-    if any(w in q_lower for w in ("registry", "profile", "configure", "setting")):
-        categories.append("configuration")
-    if intent == "synthesize" and feature == "Unknown":
-        categories.append("feature_unclear")
-
-    state["intent"] = intent
-    state["feature_area"] = feature
-    state["version_scope"] = version_scope
-    state["query_categories"] = categories
-    state.setdefault("agent_trace", []).append({
-        "agent": "IntentAgent",
-        "status": "complete",
-        "intent": intent,
-        "feature_area": feature,
-        "version_scope": version_scope,
-        "query_categories": categories,
-    })
-    return state

package/knowledge_base/agents/requirement_agent.py

@@ -1,71 +0,0 @@
-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/testcase_agent.py

@@ -1,111 +0,0 @@
-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, 
-    ScenarioWithRules,
-    GeneratedTestCase,
-    ManualTestStep,
-    BusinessRule
-)
-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 Business Rule for a specific Scenario and generate a detailed Manual Test Case.
-The test case must strictly follow the business rule.
-Output MUST be valid JSON matching this schema:
-{
-  "title": "string",
-  "priority": "critical" | "high" | "medium" | "low",
-  "preconditions": ["string"],
-  "steps": [
-    {
-      "step_number": 1,
-      "action": "string",
-      "data": "string",
-      "expected_result": "string"
-    }
-  ]
-}
-"""
-
-def generate_test_case(requirement: TestRequirement, scenario_rules: ScenarioWithRules, rule: BusinessRule) -> GeneratedTestCase:
-    """Generate a specific test case from a business rule."""
-    client = _get_llm_client()
-    
-    # Construct context
-    user_prompt = f"Requirement: {requirement.summary}\n"
-    user_prompt += f"Scenario Action: {scenario_rules.scenario.action}\n"
-    user_prompt += f"Business Rule ({rule.rule_type}): {rule.description}\n\n"
-    user_prompt += "Generate a detailed manual test case for this business rule."
-
-    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)
-        
-        # Build manual steps
-        steps = []
-        for s in data.get("steps", []):
-            if isinstance(s, dict) and "action" in s and "expected_result" in s:
-                steps.append(ManualTestStep(
-                    step_number=s.get("step_number", len(steps) + 1),
-                    action=s["action"],
-                    data=s.get("data", ""),
-                    expected_result=s["expected_result"]
-                ))
-                
-        tc_ref = f"TC_{requirement.jira_key}_S{scenario_rules.scenario.step_number:02d}_{rule.rule_type[:1].upper()}"
-        
-        tc = GeneratedTestCase(
-            tc_reference=tc_ref,
-            business_rule=rule,
-            title=data.get("title", f"Test for {rule.description}"),
-            test_type=rule.rule_type,
-            priority=data.get("priority", "medium"),
-            preconditions=data.get("preconditions", []),
-            steps=steps,
-            confidence_score=0.0,
-            confidence_metrics={}
-        )
-        logger.info(f"Generated test case {tc_ref} with {len(steps)} steps")
-        return tc
-        
-    except Exception as e:
-        logger.error(f"Failed to generate test case for rule '{rule.description}': {e}")
-        # Return a stubbed TC on failure
-        return GeneratedTestCase(
-            tc_reference=f"TC_{requirement.jira_key}_ERR",
-            business_rule=rule,
-            title="Failed to generate",
-            test_type=rule.rule_type,
-            priority="low",
-            preconditions=[],
-            steps=[],
-            confidence_score=0.0,
-            confidence_metrics={}
-        )
-
-def generate_cases_for_scenario(requirement: TestRequirement, scenario_rules: ScenarioWithRules) -> List[GeneratedTestCase]:
-    """Generate test cases for all business rules in a scenario."""
-    cases = []
-    # Enumerate to make refs unique if there are multiple of same type
-    for i, rule in enumerate(scenario_rules.business_rules):
-        tc = generate_test_case(requirement, scenario_rules, rule)
-        tc.tc_reference = f"{tc.tc_reference}{i+1:02d}"
-        cases.append(tc)
-    return cases

package/knowledge_base/agents/workflow_engine.py

@@ -1,87 +0,0 @@
-import logging
-from pathlib import Path
-from typing import List, Tuple
-
-from knowledge_base.models.test_requirement import TestRequirement, GeneratedTestCase, TestCaseWithConfidence
-from knowledge_base.agents.requirement_agent import extract_understanding
-from knowledge_base.agents.scenario_agent import generate_all_scenarios
-from knowledge_base.agents.testcase_agent import generate_cases_for_scenario
-from knowledge_base.agents.validation_agent import run_validation_pipeline
-from knowledge_base.agents.confidence_agent import compute_hybrid_confidence
-from knowledge_base.agents.automation_design_agent import design_automation_plan
-from knowledge_base.agents.script_generator_agent import generate_script
-from knowledge_base.agents.execution_validation_agent import ExecutionValidationAgent
-
-logger = logging.getLogger(__name__)
-
-class WorkflowEngine:
-    """Predictable orchestration engine replacing the bottleneck Queen Agent."""
-    
-    def __init__(self, repo_path: Path):
-        self.repo_path = repo_path
-        self.exec_validator = ExecutionValidationAgent(repo_path)
-        
-    def run_requirement_flow(self, req: TestRequirement) -> Tuple[TestRequirement, List]:
-        """Requirement -> Requirement Understanding -> Scenario -> Business Rules"""
-        logger.info(f"Starting requirement flow for {req.jira_key}")
-        
-        # 1. Understanding Layer
-        understanding = extract_understanding(req)
-        req.understanding = understanding
-        
-        # 2. Scenario & Business Rules Layer
-        scenarios_with_rules = generate_all_scenarios(req)
-        
-        # In reality, you'd persist `scenarios_with_rules` to DB here
-        return req, scenarios_with_rules
-        
-    def run_testcase_flow(self, req: TestRequirement, scenarios_with_rules: List) -> List[TestCaseWithConfidence]:
-        """Business Rules -> Test Cases -> Validation -> Confidence"""
-        logger.info(f"Starting test case flow for {req.jira_key}")
-        all_cases = []
-        
-        for sr in scenarios_with_rules:
-            # 1. Generate Test Cases
-            tcs = generate_cases_for_scenario(req, sr)
-            
-            for tc in tcs:
-                # 2. Structural/Traceability Validation
-                ok, errs = run_validation_pipeline(tc, sr)
-                if not ok:
-                    # Depending on policy, skip or mark for human review
-                    pass
-                    
-                # 3. Deterministic Confidence Scoring
-                tc_conf = compute_hybrid_confidence(tc, sr)
-                all_cases.append(tc_conf)
-                
-        # Persist to igel_generated_testcases here
-        return all_cases
-        
-    def run_script_flow(self, req: TestRequirement, test_cases: List[TestCaseWithConfidence], output_path: Path) -> Tuple[bool, str]:
-        """Approved Test Cases -> Automation Design -> Script -> Execution Validation"""
-        logger.info(f"Starting script flow for {req.jira_key}")
-        
-        # Filter for approved
-        approved = [tc for tc in test_cases if tc.is_approved]
-        if not approved:
-            return False, "No approved test cases available for automation."
-            
-        # 1. Automation Design Agent
-        plan = design_automation_plan(test_cases)
-        
-        # 2. Script Generator
-        ok, code, err = generate_script(test_cases, plan, output_path)
-        if not ok:
-            return False, err
-            
-        # 3. Execution Validation Pipeline
-        ok, status, err = self.exec_validator.validate_pipeline(code, output_path)
-        
-        # Persist to igel_automation_scripts here
-        
-        if not ok:
-            logger.warning(f"Execution validation failed ({status}): {err}")
-            return False, err
-            
-        return True, "Script successfully generated and validated."