igel-qe-core 1.0.5 → 1.0.7

package/src/agents/framework_analyzer_agent.py

@@ -0,0 +1,43 @@
+"""Framework Analyzer Agent.
+
+Consumes a diff/impact scope package and performs scoped framework analysis.
+This is intentionally scope-limited to avoid full repository rescans.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Iterable
+
+from src.agents.regression_agent import BitbucketSyncAgent
+
+logger = logging.getLogger(__name__)
+
+
+class FrameworkAnalyzerAgent:
+    """Analyze only impacted files and update framework registries."""
+
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        self._sync = BitbucketSyncAgent(repo_path)
+
+    def analyze_scope(self, analysis_targets: Iterable[Path]) -> dict:
+        targets = []
+        for t in analysis_targets:
+            p = Path(t)
+            full = p if p.is_absolute() else (self.repo_path / p)
+            if full.exists():
+                targets.append(full)
+
+        indexed_assets = self._sync.sync_changed_files(targets)
+        logger.info(
+            "FrameworkAnalyzer: targets=%d indexed_assets=%d",
+            len(targets),
+            indexed_assets,
+        )
+
+        return {
+            "analysis_targets_count": len(targets),
+            "indexed_assets": indexed_assets,
+            "analysis_targets": [str(p.relative_to(self.repo_path)) for p in targets],
+        }

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

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import re
 
-from knowledge_base.agents.state import AgenticState
+from src.agents.state import AgenticState
 
 
 def fusion_agent(state: AgenticState) -> AgenticState:
@@ -29,7 +29,7 @@ def fusion_agent(state: AgenticState) -> AgenticState:
     conflicts: list[dict] = list(kg.get("conflicts") or [])
     if not conflicts and rag:
         try:
-            from knowledge_base.core.precedence import detect_precedence_conflicts
+            from src.core.precedence import detect_precedence_conflicts
             pseudo = []
             for i, chunk in enumerate(rag[:8]):
                 pseudo.append(type("R", (), {
@@ -71,7 +71,7 @@ def fusion_agent(state: AgenticState) -> AgenticState:
     # LLM-assisted context quality when heuristic score is low
     if quality < 0.5 and rag:
         try:
-            from knowledge_base.generation.test_generator import _call_gpt
+            from src.generation.test_generator import _call_gpt
             sample = "\n".join(c.get("content", "")[:200] for c in rag[:3])
             verdict = _call_gpt(
                 "Rate context relevance 0-1 for IGEL test generation. Reply with number only.",

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

@@ -5,16 +5,16 @@ import logging
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
-from knowledge_base.agents.fusion_agent import fusion_agent
-from knowledge_base.agents.intent_agent import intent_agent
-from knowledge_base.agents.kg_agent import kg_agent
-from knowledge_base.agents.memory_agent import memory_agent
-from knowledge_base.agents.reflection_agent import reflection_agent, should_loop_back
-from knowledge_base.agents.retrieval_agent import retrieval_agent
-from knowledge_base.agents.script_agent import script_agent
-from knowledge_base.agents.state import AgenticState, initial_state
-from knowledge_base.agents.temporal_agent import temporal_agent
-from knowledge_base.agents.validation_agent import validation_agent
+from src.agents.fusion_agent import fusion_agent
+from src.agents.intent_agent import intent_agent
+from src.agents.kg_agent import kg_agent
+from src.agents.memory_agent import memory_agent
+from src.agents.reflection_agent import reflection_agent, should_loop_back
+from src.agents.retrieval_agent import retrieval_agent
+from src.agents.script_agent import script_agent
+from src.agents.state import AgenticState, initial_state
+from src.agents.temporal_agent import temporal_agent
+from src.agents.validation_agent import validation_agent
 
 logger = logging.getLogger(__name__)
 

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

@@ -1,10 +1,10 @@
 """Healing agent — Phase 7."""
 from __future__ import annotations
 
-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 knowledge_base.generation.test_generator import _call_gpt
+from src.config import cfg
+from src.memory.cognee_client import get_cognee_client
+from src.memory.memory_types import MemoryType
+from src.generation.test_generator import _call_gpt
 
 
 def propose_fix(test_id: str, flaky_history: list[dict] | None = None) -> dict:

package/src/agents/intent_agent.py

@@ -0,0 +1,30 @@
+"""Intent classification agent — unified via IntentService."""
+from __future__ import annotations
+
+from src.agents.state import AgenticState
+from src.core.intent_service import IntentService
+
+_intent_service = IntentService()
+
+
+def intent_agent(state: AgenticState) -> AgenticState:
+    query = state.get("query", "")
+    classified = _intent_service.classify(query)
+    intent = classified.intent
+    feature = classified.feature_area
+    version_scope = classified.version_scope
+    categories = classified.query_categories
+
+    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/src/agents/internal/__init__.py

@@ -0,0 +1,3 @@
+"""Internal orchestration and governance components for V2."""
+
+__all__ = []

package/src/agents/internal/approval_manager.py

@@ -0,0 +1,111 @@
+"""Approval manager for V2 orchestration governance."""
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+from src.project.ai_folder import read_approval_artifact, write_approval_artifact
+
+
+class ApprovalError(RuntimeError):
+    """Raised when a workflow stage is blocked by missing/invalid approval."""
+
+
+class ApprovalManager:
+    """Persist and validate approval checkpoints for guarded workflows."""
+
+    def __init__(self, repo_root: Path):
+        self.repo_root = repo_root
+
+    def create_pending(
+        self,
+        *,
+        jira_key: str,
+        stage: str,
+        test_reqid: str | None = None,
+        questions: list[dict] | None = None,
+        confidence: float | None = None,
+    ) -> dict:
+        approval_id = str(uuid.uuid4())
+        now = datetime.now(timezone.utc).isoformat()
+        payload = {
+            "approval_id": approval_id,
+            "jira_key": jira_key,
+            "test_reqid": test_reqid or jira_key,
+            "stage": stage,
+            "status": "PENDING_QUESTIONS" if questions else "PENDING_APPROVAL",
+            "questions": questions or [],
+            "confidence": confidence,
+            "created_at": now,
+            "updated_at": now,
+            "decision": None,
+            "actor": None,
+            "reason": None,
+        }
+        write_approval_artifact(
+            repo_root=self.repo_root,
+            jira_key=jira_key,
+            stage=stage,
+            payload=payload,
+            test_reqid=test_reqid,
+        )
+        return payload
+
+    def record_decision(
+        self,
+        *,
+        jira_key: str,
+        stage: str,
+        decision: str,
+        actor: str,
+        reason: str | None = None,
+        test_reqid: str | None = None,
+    ) -> dict:
+        current = read_approval_artifact(
+            repo_root=self.repo_root,
+            jira_key=jira_key,
+            stage=stage,
+            test_reqid=test_reqid,
+        )
+        if not current:
+            raise ApprovalError(f"No approval checkpoint found for stage '{stage}'")
+
+        norm = (decision or "").strip().lower()
+        if norm not in ("approve", "approved", "reject", "rejected"):
+            raise ApprovalError("decision must be one of: approve, approved, reject, rejected")
+
+        status = "APPROVED" if norm.startswith("approve") else "REJECTED"
+        current["status"] = status
+        current["decision"] = status
+        current["actor"] = actor
+        current["reason"] = reason
+        current["updated_at"] = datetime.now(timezone.utc).isoformat()
+
+        write_approval_artifact(
+            repo_root=self.repo_root,
+            jira_key=jira_key,
+            stage=stage,
+            payload=current,
+            test_reqid=test_reqid,
+        )
+        return current
+
+    def assert_approved(self, *, jira_key: str, stage: str, test_reqid: str | None = None) -> dict:
+        record = read_approval_artifact(
+            repo_root=self.repo_root,
+            jira_key=jira_key,
+            stage=stage,
+            test_reqid=test_reqid,
+        )
+        if not record:
+            raise ApprovalError(
+                f"Blocked by governance: missing approval checkpoint for stage '{stage}'. "
+                f"Run planning first and submit approval."
+            )
+        if record.get("status") != "APPROVED":
+            raise ApprovalError(
+                f"Blocked by governance: stage '{stage}' requires APPROVED status, "
+                f"current={record.get('status')}."
+            )
+        return record

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: