igel-qe-core 1.0.5 → 1.0.8

package/src/agents/confidence_agent.py

@@ -0,0 +1,220 @@
+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__)
+
+
+# ── Parameter Calculation Helpers ─────────────────────────────────────────────
+
+def evaluate_completeness(tc: GeneratedTestCase) -> float:
+    """Evaluate structural completeness of steps (action + data + expected_result).
+
+    Used by Structural Quality dimension.
+    Formula proxy: each complete step scores 1.0; partial steps score proportionally.
+    """
+    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_contextual_relevance(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
+    """Contextual Relevance — Degree to which generated test cases align with requirement/business context.
+
+    Formula: (No. of test steps mapped to requirement context / Total generated test steps) × 100 → normalised 0-1.
+    Mapping heuristic: a step is considered 'mapped' if its action is non-empty and can be linked back
+    to at least one of the scenario's business rules (via text intersection).
+    """
+    if not tc.steps:
+        return 0.0
+    rule_keywords: set[str] = set()
+    for rule in scenario.business_rules:
+        for word in rule.description.lower().split():
+            if len(word) > 4:
+                rule_keywords.add(word)
+
+    mapped = 0
+    for step in tc.steps:
+        action_words = set(step.action.lower().split())
+        if rule_keywords and action_words & rule_keywords:
+            mapped += 1
+        elif step.action:
+            # Fallback: if no keyword overlap but step exists, give partial credit
+            mapped += 0.5
+
+    return min(1.0, (mapped / len(tc.steps)))
+
+
+def compute_hallucination_control(tc: GeneratedTestCase, resolved_context: ResolvedContext) -> float:
+    """Hallucination — Percentage of generated artifacts NOT containing non-existent entities.
+
+    Formula: (No. of non-hallucinated entities / Total generated entities) × 100 → normalised 0-1.
+    Detection heuristic: presence of unresolved source conflicts in resolved_context signals that the
+    AI may have invented information. Zero conflicts = no hallucination detected.
+    """
+    conflict_count = len(resolved_context.conflicting_sources)
+    # Each conflict reduces confidence. Cap at 5 conflicts = 0 score.
+    return max(0.0, 1.0 - (conflict_count * 0.2))
+
+
+def compute_bias_fairness_control(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
+    """Bias/Fairness Control — Ensures generation covers all personas, locales, negative and edge cases.
+
+    Formula: (No. of required personas/scenarios covered / Total identified) × 100 → normalised 0-1.
+    Coverage heuristic: checks if positive, negative and edge rule types are present in the business rules,
+    and if the specific TC covers one of these.
+    """
+    rule_types_present = {rule.rule_type for rule in scenario.business_rules}
+    total_expected = {"positive", "negative", "edge"}
+    covered = rule_types_present & total_expected
+    coverage_ratio = len(covered) / len(total_expected)
+
+    # Bonus: TC itself covers its declared type
+    if tc.test_type in covered:
+        coverage_ratio = min(1.0, coverage_ratio + 0.15)
+
+    return round(coverage_ratio, 4)
+
+
+def compute_business_rule_coverage(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> float:
+    """Business Rule Coverage — Checks how well generated steps address the identified business rules.
+
+    Formula: (No. of business rules covered by test steps / Total business rules) × 100 → normalised 0-1.
+    """
+    if not scenario.business_rules:
+        return 1.0
+    return min(1.0, len(tc.steps) / len(scenario.business_rules))
+
+
+def compute_requirement_clarity(scenario: ScenarioWithRules, source_report: SourceReport) -> float:
+    """Requirement Clarity — How well the upstream requirement was understood.
+
+    Formula: Determined by presence of structured business rules AND multi-source corroboration.
+    """
+    has_rules = 1.0 if scenario.business_rules else 0.5
+    sources_found = sum([
+        source_report.jira_found,
+        source_report.confluence_found,
+        source_report.postgres_kb_found,
+        source_report.igel_os12_docs_found,
+    ])
+    source_bonus = min(0.5, sources_found / 4 * 0.5)
+    return min(1.0, has_rules * 0.5 + source_bonus)
+
+
+# ── Main Confidence Computation ───────────────────────────────────────────────
+
+def compute_two_level_confidence(
+    tc: GeneratedTestCase,
+    scenario: ScenarioWithRules,
+    resolved_context: ResolvedContext,
+    source_report: SourceReport,
+    policy: PolicyConfig,
+) -> TestCaseWithConfidence:
+    """Compute the full confidence score using the 8-parameter framework.
+
+    Pre-execution parameters (set here):
+      1. Contextual Relevance       – steps mapped to req context
+      2. Hallucination Control      – grounded vs invented entities
+      3. Bias/Fairness Control      – persona/scenario type coverage
+      4. Business Rule Coverage     – rules addressed by steps
+      5. Requirement Clarity        – clarity of upstream requirement
+      6. Structural Quality         – step completeness (action+data+expected)
+
+    Post-execution parameters (set by ExecutionValidationAgent / HealingAgent):
+      7. Maintainability            – complexity + duplication (in ExecutionMetrics)
+      8. First-Pass Success         – runtime result on first run (in ExecutionMetrics)
+      9. Reusability                – registry-sourced vs new components (in ExecutionMetrics)
+     10. Flakiness                  – historical inconsistency rate (in ExecutionMetrics)
+    """
+    dims = policy.confidence_dimensions
+
+    # ── Pre-Execution Dimensions ──────────────────────────────────────────────
+
+    # 1. Context Strength (informational, not weighted)
+    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. Contextual Relevance
+    contextual_relevance = compute_contextual_relevance(tc, scenario)
+
+    # 3. Hallucination Control (replaces evidence_quality)
+    hallucination_control = compute_hallucination_control(tc, resolved_context)
+
+    # 4. Bias/Fairness Control (replaces scenario_coverage)
+    bias_fairness_control = compute_bias_fairness_control(tc, scenario)
+
+    # 5. Business Rule Coverage
+    business_rule_coverage = compute_business_rule_coverage(tc, scenario)
+
+    # 6. Requirement Clarity
+    requirement_clarity = compute_requirement_clarity(scenario, source_report)
+
+    # 7. Structural Quality
+    struct_ok, _ = validate_structural(tc, scenario)
+    structural_quality = evaluate_completeness(tc) if struct_ok else 0.0
+
+    # ── Weighted Final Score ──────────────────────────────────────────────────
+    # Weights pulled from policy dimensions; field names updated to match new params
+    total = (
+        contextual_relevance   * getattr(dims, "contextual_relevance",   0.25) +
+        hallucination_control  * getattr(dims, "hallucination_control",  0.20) +
+        bias_fairness_control  * getattr(dims, "bias_fairness_control",  0.15) +
+        business_rule_coverage * getattr(dims, "business_rule_coverage", 0.15) +
+        requirement_clarity    * getattr(dims, "requirement_clarity",    0.15) +
+        structural_quality     * getattr(dims, "structural_quality",     0.10)
+    )
+
+    metrics = ConfidenceMetrics(
+        context_strength=context_strength,
+        requirement_clarity=requirement_clarity,
+        hallucination_control=hallucination_control,
+        business_rule_coverage=business_rule_coverage,
+        contextual_relevance=contextual_relevance,
+        bias_fairness_control=bias_fairness_control,
+        structural_quality=structural_quality,
+        final_confidence=round(total, 4),
+    )
+
+    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(
+            "Test case %s needs review (score: %.2f | contextual_relevance=%.2f, hallucination=%.2f, bias=%.2f)",
+            tc.tc_reference, total, contextual_relevance, hallucination_control, bias_fairness_control,
+        )
+    else:
+        logger.info("Test case %s auto-approved (score: %.2f)", tc.tc_reference, total)
+
+    return TestCaseWithConfidence(
+        test_case=tc,
+        confidence=metrics,
+        is_approved=is_approved,
+    )

package/src/agents/execution_validation_agent.py

@@ -0,0 +1,247 @@
+import ast
+import logging
+import subprocess
+from pathlib import Path
+from typing import Tuple, Set
+
+from src.db.client import get_conn
+from src.models.test_requirement import ExecutionMetrics
+
+logger = logging.getLogger(__name__)
+
+
+# ── Static Complexity Analyser (lightweight, no external deps) ─────────────────
+
+def _compute_cyclomatic_complexity(tree: ast.Module) -> int:
+    """Count decision points to approximate cyclomatic complexity.
+
+    Counts: if/elif/for/while/try/except/with/assert branches.
+    Complexity = 1 + decision_points (baseline 1 per function).
+    """
+    decision_nodes = (
+        ast.If, ast.For, ast.While, ast.Try,
+        ast.ExceptHandler, ast.With, ast.Assert,
+    )
+    return sum(1 for _ in ast.walk(tree) if isinstance(_, decision_nodes))
+
+
+def _compute_duplication_score(code: str) -> float:
+    """Approximate duplication score by detecting repeated non-trivial line blocks.
+
+    Returns a 0-100 score where 0 = no duplication, 100 = fully duplicated.
+    """
+    lines = [l.strip() for l in code.splitlines() if l.strip() and not l.strip().startswith("#")]
+    if not lines:
+        return 0.0
+    seen: dict[str, int] = {}
+    for line in lines:
+        seen[line] = seen.get(line, 0) + 1
+    duplicated = sum(count - 1 for count in seen.values() if count > 1)
+    return round(min(100.0, (duplicated / len(lines)) * 100), 2)
+
+
+def _count_style_violations(code: str) -> int:
+    """Count basic style violations (magic numbers, overly long lines, missing docstrings).
+
+    Each violation adds to the Maintainability penalty.
+    """
+    violations = 0
+    for line in code.splitlines():
+        if len(line) > 120:
+            violations += 1
+        # Detect magic numbers not assigned to a variable
+        import re
+        if re.search(r"\b(?<![\w=])\d{2,}\b", line) and "=" not in line:
+            violations += 1
+    return violations
+
+
+def compute_maintainability(code: str) -> Tuple[float, float, float, int]:
+    """Maintainability — Ease of modifying and understanding generated scripts.
+
+    Formula: 100 – ((Complexity Score + Duplication Score + Violations) / Max Score × 100)
+    Returns: (maintainability_score 0-1, complexity_raw, duplication_raw, violations_count)
+    """
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return 0.0, 0.0, 0.0, 0
+
+    complexity = _compute_cyclomatic_complexity(tree)
+    duplication = _compute_duplication_score(code)
+    violations = _count_style_violations(code)
+
+    # Normalise each sub-score to 0-100 range (caps prevent extreme values)
+    MAX_COMPLEXITY = 50.0   # treat 50+ branches as worst case
+    MAX_VIOLATIONS = 30.0   # treat 30+ violations as worst case
+
+    complexity_norm = min(100.0, (complexity / MAX_COMPLEXITY) * 100)
+    violation_norm = min(100.0, (violations / MAX_VIOLATIONS) * 100)
+
+    # Formula (all three sub-scores weighted equally within their sum)
+    penalty = (complexity_norm + duplication + violation_norm) / 3.0
+    maintainability_pct = max(0.0, 100.0 - penalty)
+    maintainability_score = round(maintainability_pct / 100.0, 4)
+
+    return maintainability_score, round(complexity_norm, 2), round(duplication, 2), violations
+
+
+class ExecutionValidationAgent:
+    """Multi-stage validation pipeline for generated automation scripts."""
+
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+
+    # ── Validation Stages ─────────────────────────────────────────────────────
+
+    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[str] = 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("Failed to query registry for %s: %s", 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:
+            ast.parse(code)
+        except SyntaxError:
+            return False, "Syntax invalid, cannot check imports."
+        # Registry-aware import validation is advisory; non-blocking.
+        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_"):
+                for arg in node.args.args:
+                    arg_name = arg.arg
+                    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."
+        try:
+            result = subprocess.run(
+                ["pytest", "--collect-only", str(file_path)],
+                capture_output=True,
+                text=True,
+                cwd=str(self.repo_path),
+            )
+            if result.returncode == 5:
+                return False, "Pytest collected 0 tests."
+            if result.returncode != 0:
+                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}"
+
+    # ── Main Pipeline ─────────────────────────────────────────────────────────
+
+    def validate_pipeline(self, code: str, file_path: Path) -> Tuple[bool, str, str, ExecutionMetrics]:
+        """Run all execution validation stages and compute ExecutionMetrics.
+
+        Returns: (passed: bool, status: str, error_msg: str, ExecutionMetrics)
+
+        ExecutionMetrics computed here:
+          - Maintainability   – AST-based complexity/duplication formula
+          - First-Pass Success – whether collection + syntax pass on first attempt
+          - Reusability        – populated by automation_design_agent (passed in plan)
+          - Flakiness          – historical; placeholder (0.0) until HealingAgent populates
+        """
+        logger.info("Starting execution validation pipeline for %s", file_path)
+
+        # ── Maintainability (always computed, even if later stages fail) ──────
+        maintainability, complexity_norm, duplication, violations = compute_maintainability(code)
+
+        ok, err = self.validate_syntax(code)
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "syntax_failed", err, exec_metrics
+
+        ok, err = self.validate_imports(code)
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "import_failed", err, exec_metrics
+
+        ok, err = self.validate_fixtures(code)
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "fixture_failed", err, exec_metrics
+
+        ok, err = self.validate_pytest_collection(file_path)
+        if not ok:
+            exec_metrics = ExecutionMetrics(
+                maintainability_score=maintainability,
+                complexity_score=complexity_norm,
+                duplication_score=duplication,
+                violations_count=violations,
+                first_pass_success=False,
+            )
+            return False, "collection_failed", err, exec_metrics
+
+        # All stages passed → First-Pass Success = True
+        exec_metrics = ExecutionMetrics(
+            maintainability_score=maintainability,
+            complexity_score=complexity_norm,
+            duplication_score=duplication,
+            violations_count=violations,
+            first_pass_success=True,
+            # reusability_score injected by caller from AutomationPlan.reusability_score
+            # flakiness_score injected by HealingAgent over time
+        )
+        logger.info(
+            "Execution validation passed for %s | maintainability=%.2f, first_pass=True",
+            file_path, maintainability,
+        )
+        return True, "passed", "", exec_metrics

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

@@ -1,7 +1,7 @@
 import json
 import logging
 from typing import Dict, Any, Optional
-from knowledge_base.db.client import get_conn
+from src.db.client import get_conn
 
 logger = logging.getLogger(__name__)
 
@@ -39,22 +39,51 @@ class FeedbackAgent:
         """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) -> list:
-        """Retrieve historical feedback for a specific target to use as generation context."""
+    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",
-                        (target_id,)
+                        """
+                        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": row[1],
-                            "corrected_data": row[2]
+                            "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