igel-qe-core 1.0.3 → 1.0.7

package/src/agents/internal/question_engine.py

@@ -0,0 +1,111 @@
+"""Question engine for governance-significant clarifications.
+
+This engine filters out low-value style/naming questions and only emits
+questions that can change coverage, risk profile, environment scope, or
+business behavior.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+_ALLOWED_CATEGORIES = {
+    "business_rule",
+    "coverage_scope",
+    "risk_acceptance",
+    "environment_decision",
+    "architecture_decision",
+}
+
+_BLOCKED_HINTS = (
+    "name",
+    "naming",
+    "format",
+    "style",
+    "folder",
+    "documentation",
+    "comment",
+)
+
+
+@dataclass
+class GovernanceQuestion:
+    category: str
+    question: str
+
+
+class QuestionEngine:
+    """Generates and filters governance-relevant questions."""
+
+    def __init__(self, max_questions: int = 5):
+        self.max_questions = max_questions
+
+    def build_questions(self, *, summary: str, description: str) -> list[dict]:
+        summary_low = (summary or "").lower()
+        desc_low = (description or "").lower()
+        text = f"{summary_low}\n{desc_low}".strip()
+
+        candidates: list[GovernanceQuestion] = []
+
+        if any(k in text for k in ("downgrade", "rollback", "migration")):
+            candidates.append(
+                GovernanceQuestion(
+                    category="coverage_scope",
+                    question="Should downgrade and rollback paths be included in scope?",
+                )
+            )
+
+        if any(k in text for k in ("os", "version", "compatibility")):
+            candidates.append(
+                GovernanceQuestion(
+                    category="environment_decision",
+                    question="Which OS versions and deployment variants are in scope?",
+                )
+            )
+
+        if any(k in text for k in ("authentication", "sso", "mfa", "security")):
+            candidates.append(
+                GovernanceQuestion(
+                    category="risk_acceptance",
+                    question="What risk posture should be used for authentication and failure handling scenarios?",
+                )
+            )
+
+        if "or" in text and any(k in text for k in ("workflow", "path", "option")):
+            candidates.append(
+                GovernanceQuestion(
+                    category="architecture_decision",
+                    question="Which workflow path is authoritative when multiple behavior options are possible?",
+                )
+            )
+
+        if any(k in text for k in ("must", "shall", "cannot", "prohibited", "not allowed")):
+            candidates.append(
+                GovernanceQuestion(
+                    category="business_rule",
+                    question="Please confirm the non-negotiable business rules that must be enforced.",
+                )
+            )
+
+        return self._filter(candidates)
+
+    def _filter(self, questions: list[GovernanceQuestion]) -> list[dict]:
+        out: list[dict] = []
+        seen: set[str] = set()
+
+        for q in questions:
+            text = q.question.strip()
+            if not text:
+                continue
+            if q.category not in _ALLOWED_CATEGORIES:
+                continue
+            low = text.lower()
+            if any(h in low for h in _BLOCKED_HINTS):
+                continue
+            if text in seen:
+                continue
+            seen.add(text)
+            out.append({"category": q.category, "question": text})
+            if len(out) >= self.max_questions:
+                break
+
+        return out

package/src/agents/internal/workflow_engine.py

@@ -0,0 +1,28 @@
+"""Internal workflow wrapper for V2 stage-gated execution.
+
+This wrapper is intentionally thin in Wave 1 and delegates execution to the
+existing deterministic WorkflowEngine while keeping a stable location for
+future governance interception.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from src.agents.workflow_engine import WorkflowEngine
+
+
+class InternalWorkflowEngine:
+    """Adapter layer used by the V2 orchestrator to call existing specialists."""
+
+    def __init__(self, repo_root: Path):
+        self._engine = WorkflowEngine(repo_root)
+
+    def run_requirement_flow(self, req: Any):
+        return self._engine.run_requirement_flow(req)
+
+    def run_testcase_flow(self, req: Any, scenarios_with_rules: list, resolved_context: Any, source_report: Any):
+        return self._engine.run_testcase_flow(req, scenarios_with_rules, resolved_context, source_report)
+
+    def run_script_flow(self, req: Any, test_cases: list, output_path: Path, plan: Any = None):
+        return self._engine.run_script_flow(req, test_cases, output_path, plan=plan)

package/{knowledge_base → src}/agents/kg_agent.py

@@ -4,9 +4,9 @@ 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
+from src.agents.state import AgenticState
+from src.config import cfg
+from src.db.client import get_conn
 
 
 def kg_agent(state: AgenticState) -> AgenticState:

package/{knowledge_base → src}/agents/memory_agent.py

@@ -1,10 +1,10 @@
 """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
+from src.agents.state import AgenticState
+from src.config import cfg
+from src.memory.cognee_client import get_cognee_client
+from src.memory.memory_types import MemoryType
 
 
 def memory_agent(state: AgenticState) -> AgenticState:

package/src/agents/orchestrator/__init__.py

@@ -0,0 +1,3 @@
+"""User-facing orchestrator module for V2."""
+
+__all__ = []

package/src/agents/orchestrator/orchestrator.py

@@ -0,0 +1,63 @@
+"""Single user-facing orchestrator façade.
+
+This module introduces a stable entrypoint for workflow selection and
+governance decisions while reusing existing specialist implementations.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from src.agents.internal.approval_manager import ApprovalManager
+from src.agents.internal.question_engine import QuestionEngine
+from src.config import cfg
+
+
+@dataclass
+class OrchestrationDecision:
+    workflow: str
+    approval_required: bool
+    questions: list[dict]
+
+
+class Orchestrator:
+    """Single front door for all user workflow requests."""
+
+    def __init__(self, repo_root: Path):
+        self.repo_root = repo_root
+        self.approvals = ApprovalManager(repo_root)
+        self.questions = QuestionEngine(max_questions=5)
+
+    def select_workflow(self, action: str) -> str:
+        mapping = {
+            "plan_test_cases": "test_case_planning",
+            "generate_test_cases": "test_case_generation",
+            "plan_automation": "automation_planning",
+            "generate_automation": "automation_generation",
+        }
+        return mapping.get(action, "generic")
+
+    def plan_gate(self, *, jira_key: str, test_reqid: str | None, summary: str, description: str, stage: str) -> OrchestrationDecision:
+        generated_questions: list[dict] = []
+        if cfg.V2_QUESTION_ENGINE_ENABLED:
+            generated_questions = self.questions.build_questions(summary=summary, description=description)
+
+        approval_required = cfg.V2_APPROVAL_MANAGER_ENABLED or cfg.V2_GOVERNANCE_ENFORCED
+        if approval_required:
+            self.approvals.create_pending(
+                jira_key=jira_key,
+                stage=stage,
+                test_reqid=test_reqid,
+                questions=generated_questions,
+            )
+
+        return OrchestrationDecision(
+            workflow=stage,
+            approval_required=approval_required,
+            questions=generated_questions,
+        )
+
+    def assert_generation_gate(self, *, jira_key: str, test_reqid: str | None, stage: str) -> dict | None:
+        if not (cfg.V2_APPROVAL_MANAGER_ENABLED or cfg.V2_GOVERNANCE_ENFORCED):
+            return None
+        return self.approvals.assert_approved(jira_key=jira_key, stage=stage, test_reqid=test_reqid)

package/{knowledge_base → src}/agents/rca_agent.py

@@ -1,10 +1,10 @@
 """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
+from src.config import cfg
+from src.graph_db.kg_traversal import traverse_failure_path
+from src.memory.cognee_client import get_cognee_client
+from src.memory.memory_types import MemoryType
 
 
 def analyze_failure(test_id: str, failure_log: str) -> dict:

package/{knowledge_base → src}/agents/reflection_agent.py

@@ -1,7 +1,7 @@
 """Reflection agent — Phase 5."""
 from __future__ import annotations
 
-from knowledge_base.agents.state import AgenticState
+from src.agents.state import AgenticState
 
 
 def reflection_agent(state: AgenticState) -> AgenticState:

package/{knowledge_base → src}/agents/regression_agent.py

@@ -1,8 +1,8 @@
 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
+from src.db.client import get_conn
+from src.agents.code_intelligence_agent import CodeIntelligenceAgent
 
 logger = logging.getLogger(__name__)
 

package/src/agents/requirement_agent.py

@@ -0,0 +1,97 @@
+import json
+import logging
+from typing import Dict, Any
+from openai import AzureOpenAI
+from src.config import cfg
+from src.core.llm_executor import get_executor, executor_enabled_for
+from src.core.orchestration_contracts import GenerationContext, LLMRequest
+from src.models.test_requirement import RequirementUnderstanding, TestRequirement
+from src.prompts.prompt_loader import load_prompt
+
+logger = logging.getLogger(__name__)
+
+_SYSTEM_PROMPT = load_prompt(
+        "requirement_understanding.md",
+        fallback=(
+                "You are an expert IGEL Quality Engineering Architect. "
+                "Analyze the requirement and return actors, entities, business_rules, validations, constraints, dependencies as JSON."
+        ),
+)
+
+_llm_client: AzureOpenAI | None = None
+
+
+def _get_llm_client() -> AzureOpenAI:
+    """Backward-compatible direct client accessor for agents not yet migrated."""
+    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 _get_llm_executor():
+    return get_executor()
+
+def extract_understanding(requirement: TestRequirement) -> RequirementUnderstanding:
+    """Analyze a requirement and extract its core semantic understanding."""
+    executor = _get_llm_executor()
+    use_executor = executor_enabled_for("RequirementAgent")
+    client = None if use_executor else _get_llm_client()
+    
+    user_prompt = f"Requirement Key: {requirement.jira_key}\nSummary: {requirement.summary}\nDescription: {requirement.description or 'None'}\n"
+    
+    try:
+        if use_executor:
+            result = executor.execute(
+                LLMRequest(
+                    system_prompt=_SYSTEM_PROMPT,
+                    user_prompt=user_prompt,
+                    task_type="requirement_understanding",
+                    agent_name="RequirementAgent",
+                    temperature=0.1,
+                    max_tokens=1500,
+                    response_format={"type": "json_object"},
+                    context=GenerationContext(
+                        jira_key=requirement.jira_key,
+                        task_type="requirement_understanding",
+                        agent_name="RequirementAgent",
+                        query=requirement.summary,
+                        metadata={"description_present": bool(requirement.description)},
+                    ),
+                )
+            )
+            content = result.content or "{}"
+        else:
+            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 → src}/agents/retrieval_agent.py

@@ -1,8 +1,8 @@
 """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
+from src.agents.state import AgenticState
+from src.retrieval.unified_query import unified_query
 
 
 def retrieval_agent(state: AgenticState) -> AgenticState:

package/{knowledge_base → src}/agents/scenario_agent.py

@@ -2,31 +2,25 @@ 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 (
+from src.config import cfg
+from src.models.test_requirement import (
     TestRequirement, 
     TestStep, 
     BusinessRule, 
     ScenarioWithRules
 )
-from knowledge_base.agents.requirement_agent import _get_llm_client
+from src.agents.requirement_agent import _get_llm_client
+from src.prompts.prompt_loader import load_prompt
 
 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"
-    }
-  ]
-}
-"""
+_SYSTEM_PROMPT = load_prompt(
+        "scenario_generator.md",
+        fallback=(
+                "Generate exhaustive business rules for the given scenario step. "
+                "Return JSON with business_rules entries containing rule_type and description."
+        ),
+)
 
 def generate_business_rules(requirement: TestRequirement, step: TestStep) -> ScenarioWithRules:
     """Analyze a scenario (test step) and extract exhaustive business rules."""

package/{knowledge_base → src}/agents/script_agent.py

@@ -1,17 +1,17 @@
 """Script generation agent — Phase 5."""
 from __future__ import annotations
 
-from knowledge_base.agents.state import AgenticState
-from knowledge_base.core.confidence import flatten_confidence_for_api, score_generation
-from knowledge_base.config import cfg
-from knowledge_base.generation.prompts import (
+from src.agents.state import AgenticState
+from src.core.confidence import flatten_confidence_for_api, score_generation
+from src.config import cfg
+from src.generation.prompts import (
     PromptContext,
     build_markdown_user_prompt,
     build_python_user_prompt,
     build_system_prompt,
 )
-from knowledge_base.retrieval.retriever import SearchResult
-from knowledge_base.generation.test_generator import _call_gpt, _infer_feature_area, _strip_code_fences
+from src.retrieval.retriever import SearchResult
+from src.generation.test_generator import _call_gpt, _infer_feature_area, _strip_code_fences
 
 
 def script_agent(state: AgenticState) -> AgenticState:

package/{knowledge_base → src}/agents/script_generator_agent.py

@@ -3,19 +3,21 @@ import logging
 from typing import List, Tuple
 from pathlib import Path
 from openai import AzureOpenAI
-from knowledge_base.config import cfg
-from knowledge_base.agents.requirement_agent import _get_llm_client
-from knowledge_base.models.test_requirement import TestCaseWithConfidence
-from knowledge_base.agents.automation_design_agent import AutomationPlan
+from src.config import cfg
+from src.agents.requirement_agent import _get_llm_client
+from src.models.test_requirement import TestCaseWithConfidence
+from src.agents.automation_design_agent import AutomationPlan
+from src.prompts.prompt_loader import load_prompt
 
 logger = logging.getLogger(__name__)
 
-_SYSTEM_PROMPT = """You are an expert IGEL Quality Engineering Automation Developer.
-Your task is to generate a robust, enterprise-grade `pytest` test script for the provided approved test cases.
-You MUST strictly adhere to the provided Automation Plan.
-Do NOT import or use ANY fixtures, page objects, or utilities that are not explicitly listed in the Automation Plan.
-Write valid Python 3 code. Include docstrings.
-"""
+_SYSTEM_PROMPT = load_prompt(
+    "script_generator.md",
+    fallback=(
+        "Generate robust pytest script from approved test cases and automation plan. "
+        "Use only plan-approved assets and output valid Python 3."
+    ),
+)
 
 def generate_script(test_cases: List[TestCaseWithConfidence], plan: AutomationPlan, output_path: Path) -> Tuple[bool, str, str]:
     """

package/{knowledge_base → src}/agents/temporal_agent.py

@@ -1,8 +1,8 @@
 """Temporal agent — Phase 6 Graphiti integration."""
 from __future__ import annotations
 
-from knowledge_base.agents.state import AgenticState
-from knowledge_base.config import cfg
+from src.agents.state import AgenticState
+from src.config import cfg
 
 
 def temporal_agent(state: AgenticState) -> AgenticState:
@@ -31,7 +31,7 @@ def temporal_agent(state: AgenticState) -> AgenticState:
         return state
 
     try:
-        from knowledge_base.graph_db.graphiti_client import get_graphiti_client
+        from src.graph_db.graphiti_client import get_graphiti_client
 
         client = get_graphiti_client()
         temporal = client.query_feature_changes(feature, version)