igel-qe-core 1.0.3 → 1.0.7

package/knowledge_base/agents/__init__.py

@@ -1,6 +0,0 @@
-"""LangGraph agents package — Phase 5+."""
-
-from knowledge_base.agents.graph import build_graph, generate_agentic
-from knowledge_base.agents.state import AgenticState, initial_state
-
-__all__ = ["AgenticState", "initial_state", "build_graph", "generate_agentic"]

package/knowledge_base/agents/confidence_agent.py

@@ -1,94 +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
-    tc.confidence_metrics = 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/feedback_agent.py

@@ -1,56 +0,0 @@
-import json
-import logging
-from typing import Dict, Any, Optional
-from knowledge_base.db.client import get_conn
-
-logger = logging.getLogger(__name__)
-
-class FeedbackAgent:
-    """Agent responsible for capturing and applying 4-level granular feedback."""
-    
-    def capture_feedback(self, level: str, target_id: str, feedback_type: str, user_comment: str, corrected_data: Optional[Dict] = None) -> bool:
-        """
-        Store granular feedback.
-        Level must be one of: 'requirement', 'scenario', 'testcase', 'teststep'.
-        """
-        if level not in ["requirement", "scenario", "testcase", "teststep"]:
-            logger.error(f"Invalid feedback level: {level}")
-            return False
-            
-        try:
-            with get_conn() as conn:
-                with conn.cursor() as cur:
-                    cur.execute(
-                        """
-                        INSERT INTO igel_granular_feedback 
-                        (level, target_id, feedback_type, user_comment, corrected_data)
-                        VALUES (%s, %s, %s, %s, %s::jsonb)
-                        """,
-                        (level, target_id, feedback_type, user_comment, json.dumps(corrected_data) if corrected_data else None)
-                    )
-                conn.commit()
-            logger.info(f"Captured {level} feedback for {target_id}")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to capture feedback: {e}")
-            return False
-
-    def get_feedback_for_target(self, target_id: str) -> list:
-        """Retrieve historical feedback for a specific target to use as generation context."""
-        feedback = []
-        try:
-            with get_conn() as conn:
-                with conn.cursor() as cur:
-                    cur.execute(
-                        "SELECT feedback_type, user_comment, corrected_data FROM igel_granular_feedback WHERE target_id = %s",
-                        (target_id,)
-                    )
-                    for row in cur.fetchall():
-                        feedback.append({
-                            "type": row[0],
-                            "comment": row[1],
-                            "corrected_data": row[2]
-                        })
-        except Exception as e:
-            logger.error(f"Failed to get feedback: {e}")
-        return feedback

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) -> TestRequirement:
-        """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."