igel-qe-core 1.0.3 → 1.0.7

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

@@ -2,11 +2,12 @@ import json
 import logging
 from typing import List, Dict, Any
 from pydantic import BaseModel, Field
-from knowledge_base.config import cfg
-from knowledge_base.agents.requirement_agent import _get_llm_client
-from knowledge_base.db.client import get_conn
-from knowledge_base.embeddings.azure_embedder import get_embedding
-from knowledge_base.models.test_requirement import TestCaseWithConfidence
+from src.config import cfg
+from src.agents.requirement_agent import _get_llm_client
+from src.db.client import get_conn
+from src.embeddings.azure_embedder import embed_single
+from src.models.test_requirement import TestCaseWithConfidence
+from src.prompts.prompt_loader import load_prompt
 
 logger = logging.getLogger(__name__)
 
@@ -15,22 +16,18 @@ class AutomationPlan(BaseModel):
     fixtures: List[str] = Field(default_factory=list)
     utilities: List[str] = Field(default_factory=list)
     
-_SYSTEM_PROMPT = """You are an expert IGEL Quality Engineering Automation Architect.
-Your task is to design an Automation Plan for a given set of approved test cases.
-You will be provided with a list of available Page Objects, Fixtures, and Utilities from the Asset Registry.
-You must ONLY select items from the provided available lists. Do NOT invent new page objects or fixtures.
-Output MUST be valid JSON matching this schema:
-{
-  "page_objects": ["string"],
-  "fixtures": ["string"],
-  "utilities": ["string"]
-}
-"""
+_SYSTEM_PROMPT = load_prompt(
+        "automation_design.md",
+        fallback=(
+                "Design automation plan from approved test cases and available assets. "
+                "Select only from provided lists and return JSON with page_objects, fixtures, utilities."
+        ),
+)
 
 def _semantic_search_assets(query: str, limit: int = 20) -> Dict[str, List[str]]:
     """Retrieve relevant assets from the Asset Registry based on semantic similarity to the query."""
     try:
-        embedding = get_embedding(query)
+        embedding = embed_single(query)
         assets = {"page_object": [], "fixture": [], "utility": [], "base_class": [], "api_client": []}
         
         with get_conn() as conn:

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

@@ -4,8 +4,8 @@ import logging
 from pathlib import Path
 from typing import List, Dict, Any, Optional
 
-from knowledge_base.db.client import get_conn
-from knowledge_base.embeddings.azure_embedder import get_embedding
+from src.db.client import get_conn
+from src.embeddings.azure_embedder import get_embedding
 
 logger = logging.getLogger(__name__)
 

package/src/agents/confidence_agent.py

@@ -0,0 +1,114 @@
+import logging
+from src.models.test_requirement import (
+    GeneratedTestCase, 
+    ScenarioWithRules,
+    ConfidenceMetrics,
+    TestCaseWithConfidence
+)
+from src.core.context_engine import SourceReport
+from src.core.evidence_resolver import ResolvedContext
+from src.config.policy_config import PolicyConfig
+from src.agents.validation_agent import validate_structural
+
+logger = logging.getLogger(__name__)
+
+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 compute_two_level_confidence(
+    tc: GeneratedTestCase,
+    scenario: ScenarioWithRules,
+    resolved_context: ResolvedContext,
+    source_report: SourceReport,
+    policy: PolicyConfig,
+) -> TestCaseWithConfidence:
+    """
+    Computes two levels of confidence using purely deterministic structural checks.
+    """
+    dims = policy.confidence_dimensions
+
+    # 1. Context Strength (Informational)
+    sources_found = sum([
+        source_report.jira_found, source_report.confluence_found,
+        source_report.postgres_kb_found, source_report.igel_os12_docs_found,
+    ])
+    context_strength = min(1.0, sources_found / 4.0)
+
+    # 2. Generation Confidence: Requirement Clarity (25%)
+    # Deterministic check: Are ACs, Business Rules, Dependencies, Environment present in the structured scenario?
+    # Since our schema for ScenarioWithRules just has scenario and business_rules, 
+    # we check for presence of multiple business_rules as a proxy for clarity.
+    requirement_clarity = 1.0 if scenario.business_rules else 0.5
+
+    # 3. Generation Confidence: Evidence Quality (20%)
+    # Deterministic: Based on resolved conflicts
+    conflict_count = len(resolved_context.conflicting_sources)
+    evidence_quality = 1.0 if conflict_count == 0 else max(0.0, 1.0 - (0.3 * conflict_count))
+
+    # 4. Generation Confidence: Business Rule Coverage (15%)
+    # Deterministic: Number of extracted rule objects vs mapped steps
+    rule_coverage = 1.0 if len(tc.steps) >= len(scenario.business_rules) else 0.5
+
+    # 5. Generation Confidence: Traceability Coverage (15%)
+    # Deterministic: Do steps have mapped requirement IDs? (Proxy using tc_reference mapped)
+    traceability = 1.0 if "S" in tc.tc_reference and tc.business_rule else 0.0
+
+    # 6. Generation Confidence: Scenario Coverage (15%)
+    # Deterministic: Does the generated suite contain Positive + Negative + Edge tags?
+    # Checking the single TC test_type
+    scenario_score = 1.0 if tc.test_type in ["positive", "negative", "edge"] else 0.5
+
+    # 7. Generation Confidence: Structural Quality (10%)
+    # Deterministic: Preconditions, steps, expected results (existing validation_agent.py)
+    struct_ok, struct_errs = validate_structural(tc, scenario)
+    structural_quality = evaluate_completeness(tc) if struct_ok else 0.0
+
+    # Weighted total (Final Confidence)
+    total = (
+        requirement_clarity * dims.requirement_clarity +
+        evidence_quality * dims.evidence_quality +
+        rule_coverage * dims.business_rule_coverage +
+        traceability * dims.traceability_coverage +
+        scenario_score * dims.scenario_coverage +
+        structural_quality * dims.structural_quality
+    )
+
+    metrics = ConfidenceMetrics(
+        context_strength=context_strength,
+        requirement_clarity=requirement_clarity,
+        evidence_quality=evidence_quality,
+        business_rule_coverage=rule_coverage,
+        traceability_coverage=traceability,
+        scenario_coverage=scenario_score,
+        structural_quality=structural_quality,
+        final_confidence=total,
+    )
+
+    tc.confidence_score = total
+    tc.confidence_metrics = metrics.model_dump() if hasattr(metrics, 'model_dump') else metrics.dict()
+
+    bands = policy.confidence_bands
+    is_approved = total >= bands.auto_approved
+
+    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 → src}/agents/execution_validation_agent.py

@@ -4,7 +4,7 @@ import subprocess
 from pathlib import Path
 from typing import Tuple, List, Set
 
-from knowledge_base.db.client import get_conn
+from src.db.client import get_conn
 
 logger = logging.getLogger(__name__)
 

package/src/agents/feedback_agent.py

@@ -0,0 +1,89 @@
+import json
+import logging
+from typing import Dict, Any, Optional
+from src.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 submit(self, level: str, target_id: str, feedback_type: str, user_comment: str, corrected_data: Optional[Dict] = None) -> bool:
+        """Alias for capture_feedback for CLI compatibility."""
+        return self.capture_feedback(level, target_id, feedback_type, user_comment, corrected_data)
+
+    def get_feedback_for_target(self, target_id: str, limit: int = 5, max_chars: int = 800) -> list:
+        """Retrieve historical feedback for a specific target to use as generation context.
+
+        Args:
+            target_id:  The target entity ID (requirement key, test case ID, etc.)
+            limit:      Maximum number of feedback items to return (default 5).
+            max_chars:  Hard cap on total combined character length of all returned
+                        user_comment fields (default 800). Items are included in
+                        descending ID order and truncated once the cap is reached.
+
+        Returns:
+            List of feedback dicts, each with keys: type, comment, corrected_data.
+            Total len(item["comment"]) across all items ≤ max_chars.
+        """
+        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
+                        ORDER BY id DESC
+                        LIMIT %s
+                        """,
+                        (target_id, limit),
+                    )
+                    total_chars = 0
+                    for row in cur.fetchall():
+                        comment = row[1] or ""
+                        if total_chars + len(comment) > max_chars:
+                            # Truncate comment to fit within the budget
+                            remaining = max_chars - total_chars
+                            if remaining <= 0:
+                                break
+                            comment = comment[:remaining]
+                        feedback.append({
+                            "type": row[0],
+                            "comment": comment,
+                            "corrected_data": row[2],
+                        })
+                        total_chars += len(comment)
+                        if total_chars >= max_chars:
+                            break
+        except Exception as e:
+            logger.error(f"Failed to get feedback: {e}")
+        return feedback

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