igel-qe-core 1.0.0

package/knowledge_base/agents/script_agent.py

@@ -0,0 +1,121 @@
+"""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 (
+    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
+
+
+def script_agent(state: AgenticState) -> AgenticState:
+    query = state.get("query", "")
+    fused = state.get("fused_context") or {}
+    test_id = state.get("test_id") or "TC_AGENT_001"
+    feature = state.get("feature_area") or _infer_feature_area(query)
+    product = state.get("product")
+    output_format = state.get("output_format", "both")
+
+    rag_chunks_raw = state.get("rag_chunks", [])
+    search_results = []
+    for i, c in enumerate(rag_chunks_raw):
+        search_results.append(SearchResult(
+            child_chunk_id=c.get("chunk_id", str(i)),
+            parent_chunk_id=c.get("chunk_id", str(i)),
+            document_id="",
+            child_content=c.get("content", "")[:500],
+            parent_content=c.get("content", ""),
+            section_title=c.get("source_name", ""),
+            file_name=c.get("source_name", ""),
+            product=product or "IGEL",
+            chunk_type="procedure",
+            rrf_score=c.get("rrf_score", 0.0),
+            rerank_score=c.get("rerank_score"),
+        ))
+
+    extra_blocks = []
+    if fused.get("memory_insights"):
+        extra_blocks.append("## Operational Memory Insights\n" + "\n".join(f"- {m}" for m in fused["memory_insights"]))
+    if fused.get("temporal_changes"):
+        extra_blocks.append("## Version-Specific Context\n" + str(fused["temporal_changes"]))
+    if state.get("validation_errors"):
+        extra_blocks.append("## Validation Errors\n" + "\n".join(state["validation_errors"]))
+    if state.get("force_to_validation") and fused.get("missing_signals"):
+        extra_blocks.append("⚠️ CONTEXT GAPS DETECTED\n" + "\n".join(fused["missing_signals"]))
+
+    kg_block = _format_kg_block(fused)
+    prefix = "\n\n".join(extra_blocks + ([kg_block] if kg_block else []))
+
+    web_block = fused.get("web_block") or (state.get("web_context") or {}).get("block", "")
+    mcp_block = fused.get("mcp_block") or (state.get("mcp_context") or {}).get("block", "")
+    kg_from_retrieval = state.get("kg_context_block") or ""
+
+    ctx = PromptContext(
+        topic=query,
+        test_id=test_id,
+        feature_area=feature,
+        product=product,
+        context_chunks=search_results,
+        kg_context_block="\n\n".join(p for p in [kg_from_retrieval, prefix] if p),
+        web_context_block=web_block,
+        mcp_context_block=mcp_block,
+        skip_assemble_window=True,
+    )
+
+    markdown = ""
+    python_out = None
+
+    try:
+        if output_format in ("md", "both"):
+            md_prompt = build_markdown_user_prompt(ctx)
+            if "version_unspecified" in state.get("query_categories", []):
+                md_prompt = "⚠️ VERSION NOT CONFIRMED\n\n" + md_prompt
+            markdown = _call_gpt(build_system_prompt(), md_prompt, max_tokens=4096, temperature=0.2)
+
+        if output_format in ("py", "both"):
+            py_prompt = build_python_user_prompt(ctx, markdown or query)
+            raw = _call_gpt(build_system_prompt(), py_prompt, max_tokens=3072, temperature=0.1)
+            python_out = _strip_code_fences(raw)
+    except Exception as e:
+        state.setdefault("agent_trace", []).append({
+            "agent": "ScriptAgent", "status": "error", "reason": str(e),
+        })
+        state["markdown_output"] = f"⚠️ Generation failed: {e}"
+        return state
+
+    if cfg.EVAL_ENABLED:
+        raw_conf = score_generation(
+            query=query,
+            markdown_output=markdown,
+            python_output=python_out,
+            retrieved_chunks=search_results,
+            retrieval_metadata={"chunk_count": len(search_results)},
+            kg_entities=state.get("kg_entities"),
+        )
+        state["confidence"] = flatten_confidence_for_api(raw_conf)
+
+    state["markdown_output"] = markdown
+    state["python_output"] = python_out
+    state.setdefault("agent_trace", []).append({
+        "agent": "ScriptAgent",
+        "status": "complete",
+        "confidence": state.get("confidence", {}).get("publish"),
+    })
+    return state
+
+
+def _format_kg_block(fused: dict) -> str:
+    lines = []
+    for k in fused.get("registry_keys") or []:
+        key = k.get("key", k) if isinstance(k, dict) else k
+        lines.append(f"Registry: {key}")
+    for p in fused.get("ui_paths") or []:
+        path = p.get("path", p) if isinstance(p, dict) else p
+        lines.append(f"UI Path: {path}")
+    return "\n".join(lines)

package/knowledge_base/agents/script_generator_agent.py

@@ -0,0 +1,77 @@
+import json
+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
+
+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.
+"""
+
+def generate_script(test_cases: List[TestCaseWithConfidence], plan: AutomationPlan, output_path: Path) -> Tuple[bool, str, str]:
+    """
+    Generate pytest code for the given test cases using the specified automation plan.
+    Returns (success, generated_code, error_message).
+    """
+    client = _get_llm_client()
+    
+    approved_tcs = [tc.test_case for tc in test_cases if tc.is_approved]
+    if not approved_tcs:
+        return False, "", "No approved test cases to automate."
+        
+    user_prompt = "Automation Plan (STRICT COMPLIANCE REQUIRED):\n"
+    user_prompt += f"Allowed Page Objects: {', '.join(plan.page_objects)}\n"
+    user_prompt += f"Allowed Fixtures: {', '.join(plan.fixtures)}\n"
+    user_prompt += f"Allowed Utilities: {', '.join(plan.utilities)}\n\n"
+    
+    user_prompt += "Test Cases to Automate:\n"
+    for tc in approved_tcs:
+        user_prompt += f"\n--- Test Case: {tc.title} ({tc.tc_reference}) ---\n"
+        for step in tc.steps:
+            user_prompt += f"Step {step.step_number}: {step.action} (Data: {step.data}) -> Expected: {step.expected_result}\n"
+
+    try:
+        response = client.chat.completions.create(
+            model=cfg.AZURE_DEPLOYMENT,
+            messages=[
+                {"role": "system", "content": _SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=0.1, # Extremely low temperature for code generation
+            max_tokens=4000,
+        )
+        
+        content = response.choices[0].message.content or ""
+        
+        # Strip markdown code fences if present
+        code = content
+        if code.startswith("```python"):
+            code = code.split("```python")[1]
+        if code.startswith("```"):
+            code = code.split("```")[1]
+        if code.endswith("```"):
+            code = code.rsplit("```", 1)[0]
+            
+        code = code.strip()
+        
+        # Ensure output directory exists
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(code)
+            
+        logger.info(f"Generated pytest script at {output_path}")
+        return True, code, ""
+        
+    except Exception as e:
+        err = f"Failed to generate script: {e}"
+        logger.error(err)
+        return False, "", err

package/knowledge_base/agents/state.py

@@ -0,0 +1,53 @@
+"""LangGraph agent state schema — Phase 5."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+# Dict-based state (compatible with Python 3.7+; TypedDict requires 3.8+)
+AgenticState = Dict[str, Any]
+
+
+def initial_state(
+    query: str,
+    *,
+    product: Optional[str] = None,
+    top_k: int = 8,
+    output_format: str = "both",
+    test_id: Optional[str] = None,
+    raw_request: Optional[dict] = None,
+) -> AgenticState:
+    return {
+        "query": query,
+        "raw_request": raw_request or {},
+        "intent": "",
+        "feature_area": "Unknown",
+        "version_scope": "unspecified",
+        "query_categories": [],
+        "rag_chunks": [],
+        "kg_entities": {},
+        "web_context": {"block": "", "hits": []},
+        "mcp_context": {"block": "", "hits": [], "sources_queried": []},
+        "sources_summary": {},
+        "kg_context_block": "",
+        "temporal_context": {},
+        "memory_context": [],
+        "fused_context": {},
+        "reflection_notes": [],
+        "reflection_count": 0,
+        "force_to_validation": False,
+        "validation_errors": [],
+        "validation_warnings": [],
+        "validation_passed": True,
+        "registry_keys_verified": [],
+        "ui_paths_verified": [],
+        "markdown_output": "",
+        "python_output": None,
+        "sources_used": [],
+        "confidence": {},
+        "agent_trace": [],
+        "feedback_id": None,
+        "product": product,
+        "top_k": top_k,
+        "output_format": output_format,
+        "test_id": test_id,
+    }

package/knowledge_base/agents/temporal_agent.py

@@ -0,0 +1,48 @@
+"""Temporal agent — Phase 6 Graphiti integration."""
+from __future__ import annotations
+
+from knowledge_base.agents.state import AgenticState
+from knowledge_base.config import cfg
+
+
+def temporal_agent(state: AgenticState) -> AgenticState:
+    version = state.get("version_scope", "unspecified")
+    categories = state.get("query_categories", [])
+    feature = state.get("feature_area", "Unknown")
+
+    if version == "unspecified" and "version_specific" not in categories:
+        state["temporal_context"] = {
+            "status": "skipped",
+            "reason": "No version scope specified",
+        }
+        state.setdefault("agent_trace", []).append({
+            "agent": "TemporalAgent", "status": "skipped",
+        })
+        return state
+
+    if not cfg.GRAPHITI_ENABLED:
+        state["temporal_context"] = {
+            "status": "skipped",
+            "reason": "Graphiti not enabled (GRAPHITI_ENABLED=false)",
+        }
+        state.setdefault("agent_trace", []).append({
+            "agent": "TemporalAgent", "status": "skipped", "reason": "Graphiti disabled",
+        })
+        return state
+
+    try:
+        from knowledge_base.graph_db.graphiti_client import get_graphiti_client
+
+        client = get_graphiti_client()
+        temporal = client.query_feature_changes(feature, version)
+        state["temporal_context"] = temporal
+        status = temporal.get("status", "complete")
+    except Exception as e:
+        state["temporal_context"] = {"status": "error", "reason": str(e)}
+        status = "error"
+
+    state.setdefault("agent_trace", []).append({
+        "agent": "TemporalAgent", "status": status,
+        "version_queried": version,
+    })
+    return state

package/knowledge_base/agents/testcase_agent.py

@@ -0,0 +1,111 @@
+import json
+import logging
+from typing import List, Dict, Any
+from openai import AzureOpenAI
+from knowledge_base.config import cfg
+from knowledge_base.models.test_requirement import (
+    TestRequirement, 
+    ScenarioWithRules,
+    GeneratedTestCase,
+    ManualTestStep,
+    BusinessRule
+)
+from knowledge_base.agents.requirement_agent import _get_llm_client
+
+logger = logging.getLogger(__name__)
+
+_SYSTEM_PROMPT = """You are an expert IGEL Quality Engineering Architect.
+Your task is to take a Business Rule for a specific Scenario and generate a detailed Manual Test Case.
+The test case must strictly follow the business rule.
+Output MUST be valid JSON matching this schema:
+{
+  "title": "string",
+  "priority": "critical" | "high" | "medium" | "low",
+  "preconditions": ["string"],
+  "steps": [
+    {
+      "step_number": 1,
+      "action": "string",
+      "data": "string",
+      "expected_result": "string"
+    }
+  ]
+}
+"""
+
+def generate_test_case(requirement: TestRequirement, scenario_rules: ScenarioWithRules, rule: BusinessRule) -> GeneratedTestCase:
+    """Generate a specific test case from a business rule."""
+    client = _get_llm_client()
+    
+    # Construct context
+    user_prompt = f"Requirement: {requirement.summary}\n"
+    user_prompt += f"Scenario Action: {scenario_rules.scenario.action}\n"
+    user_prompt += f"Business Rule ({rule.rule_type}): {rule.description}\n\n"
+    user_prompt += "Generate a detailed manual test case for this business rule."
+
+    try:
+        response = client.chat.completions.create(
+            model=cfg.AZURE_DEPLOYMENT,
+            messages=[
+                {"role": "system", "content": _SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            response_format={"type": "json_object"},
+            temperature=0.2,
+            max_tokens=2000,
+        )
+        
+        content = response.choices[0].message.content or "{}"
+        data = json.loads(content)
+        
+        # Build manual steps
+        steps = []
+        for s in data.get("steps", []):
+            if isinstance(s, dict) and "action" in s and "expected_result" in s:
+                steps.append(ManualTestStep(
+                    step_number=s.get("step_number", len(steps) + 1),
+                    action=s["action"],
+                    data=s.get("data", ""),
+                    expected_result=s["expected_result"]
+                ))
+                
+        tc_ref = f"TC_{requirement.jira_key}_S{scenario_rules.scenario.step_number:02d}_{rule.rule_type[:1].upper()}"
+        
+        tc = GeneratedTestCase(
+            tc_reference=tc_ref,
+            business_rule=rule,
+            title=data.get("title", f"Test for {rule.description}"),
+            test_type=rule.rule_type,
+            priority=data.get("priority", "medium"),
+            preconditions=data.get("preconditions", []),
+            steps=steps,
+            confidence_score=0.0,
+            confidence_metrics={}
+        )
+        logger.info(f"Generated test case {tc_ref} with {len(steps)} steps")
+        return tc
+        
+    except Exception as e:
+        logger.error(f"Failed to generate test case for rule '{rule.description}': {e}")
+        # Return a stubbed TC on failure
+        return GeneratedTestCase(
+            tc_reference=f"TC_{requirement.jira_key}_ERR",
+            business_rule=rule,
+            title="Failed to generate",
+            test_type=rule.rule_type,
+            priority="low",
+            preconditions=[],
+            steps=[],
+            confidence_score=0.0,
+            confidence_metrics={}
+        )
+
+def generate_cases_for_scenario(requirement: TestRequirement, scenario_rules: ScenarioWithRules) -> List[GeneratedTestCase]:
+    """Generate test cases for all business rules in a scenario."""
+    cases = []
+    # Enumerate to make refs unique if there are multiple of same type
+    for i, rule in enumerate(scenario_rules.business_rules):
+        tc = generate_test_case(requirement, scenario_rules, rule)
+        tc.tc_reference = f"{tc.tc_reference}{i+1:02d}"
+        cases.append(tc)
+    return cases

package/knowledge_base/agents/validation_agent.py

@@ -0,0 +1,49 @@
+import logging
+from typing import Tuple, List
+from knowledge_base.models.test_requirement import GeneratedTestCase, ScenarioWithRules, TestRequirement
+
+logger = logging.getLogger(__name__)
+
+def validate_structural(tc: GeneratedTestCase) -> Tuple[bool, List[str]]:
+    """Verify structural integrity of the generated test case."""
+    errors = []
+    
+    if not tc.title or len(tc.title) < 5:
+        errors.append("Title is missing or too short")
+    if not tc.steps:
+        errors.append("No steps generated")
+    
+    for i, step in enumerate(tc.steps):
+        if not step.action:
+            errors.append(f"Step {step.step_number}: Missing action")
+        if not step.expected_result:
+            errors.append(f"Step {step.step_number}: Missing expected result")
+            
+    return len(errors) == 0, errors
+
+def validate_traceability(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> Tuple[bool, List[str]]:
+    """Verify test case traces back to the business rule and scenario."""
+    errors = []
+    
+    # In a real system, you might use an LLM or embedding to verify the generated steps
+    # actually cover the specific business rule constraint.
+    # For now, we perform basic deterministic checks.
+    if tc.business_rule.description not in [r.description for r in scenario.business_rules]:
+        errors.append("Test case business rule does not belong to the parent scenario")
+        
+    return len(errors) == 0, errors
+
+def run_validation_pipeline(tc: GeneratedTestCase, scenario: ScenarioWithRules) -> Tuple[bool, List[str]]:
+    """Run all validation checks before confidence scoring."""
+    all_errors = []
+    
+    struct_ok, struct_errs = validate_structural(tc)
+    all_errors.extend(struct_errs)
+    
+    trace_ok, trace_errs = validate_traceability(tc, scenario)
+    all_errors.extend(trace_errs)
+    
+    if all_errors:
+        logger.warning(f"Validation failed for {tc.tc_reference}: {', '.join(all_errors)}")
+        
+    return len(all_errors) == 0, all_errors

package/knowledge_base/agents/workflow_engine.py

@@ -0,0 +1,87 @@
+import logging
+from pathlib import Path
+from typing import List, Tuple
+
+from knowledge_base.models.test_requirement import TestRequirement, GeneratedTestCase, TestCaseWithConfidence
+from knowledge_base.agents.requirement_agent import extract_understanding
+from knowledge_base.agents.scenario_agent import generate_all_scenarios
+from knowledge_base.agents.testcase_agent import generate_cases_for_scenario
+from knowledge_base.agents.validation_agent import run_validation_pipeline
+from knowledge_base.agents.confidence_agent import compute_hybrid_confidence
+from knowledge_base.agents.automation_design_agent import design_automation_plan
+from knowledge_base.agents.script_generator_agent import generate_script
+from knowledge_base.agents.execution_validation_agent import ExecutionValidationAgent
+
+logger = logging.getLogger(__name__)
+
+class WorkflowEngine:
+    """Predictable orchestration engine replacing the bottleneck Queen Agent."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        self.exec_validator = ExecutionValidationAgent(repo_path)
+        
+    def run_requirement_flow(self, req: TestRequirement) -> TestRequirement:
+        """Requirement -> Requirement Understanding -> Scenario -> Business Rules"""
+        logger.info(f"Starting requirement flow for {req.jira_key}")
+        
+        # 1. Understanding Layer
+        understanding = extract_understanding(req)
+        req.understanding = understanding
+        
+        # 2. Scenario & Business Rules Layer
+        scenarios_with_rules = generate_all_scenarios(req)
+        
+        # In reality, you'd persist `scenarios_with_rules` to DB here
+        return req, scenarios_with_rules
+        
+    def run_testcase_flow(self, req: TestRequirement, scenarios_with_rules: List) -> List[TestCaseWithConfidence]:
+        """Business Rules -> Test Cases -> Validation -> Confidence"""
+        logger.info(f"Starting test case flow for {req.jira_key}")
+        all_cases = []
+        
+        for sr in scenarios_with_rules:
+            # 1. Generate Test Cases
+            tcs = generate_cases_for_scenario(req, sr)
+            
+            for tc in tcs:
+                # 2. Structural/Traceability Validation
+                ok, errs = run_validation_pipeline(tc, sr)
+                if not ok:
+                    # Depending on policy, skip or mark for human review
+                    pass
+                    
+                # 3. Deterministic Confidence Scoring
+                tc_conf = compute_hybrid_confidence(tc, sr)
+                all_cases.append(tc_conf)
+                
+        # Persist to igel_generated_testcases here
+        return all_cases
+        
+    def run_script_flow(self, req: TestRequirement, test_cases: List[TestCaseWithConfidence], output_path: Path) -> Tuple[bool, str]:
+        """Approved Test Cases -> Automation Design -> Script -> Execution Validation"""
+        logger.info(f"Starting script flow for {req.jira_key}")
+        
+        # Filter for approved
+        approved = [tc for tc in test_cases if tc.is_approved]
+        if not approved:
+            return False, "No approved test cases available for automation."
+            
+        # 1. Automation Design Agent
+        plan = design_automation_plan(test_cases)
+        
+        # 2. Script Generator
+        ok, code, err = generate_script(test_cases, plan, output_path)
+        if not ok:
+            return False, err
+            
+        # 3. Execution Validation Pipeline
+        ok, status, err = self.exec_validator.validate_pipeline(code, output_path)
+        
+        # Persist to igel_automation_scripts here
+        
+        if not ok:
+            logger.warning(f"Execution validation failed ({status}): {err}")
+            return False, err
+            
+        return True, "Script successfully generated and validated."

package/knowledge_base/alembic/README.md

@@ -0,0 +1,104 @@
+# Database Migrations with Alembic
+
+## Overview
+
+This directory contains Alembic migrations for the IGEL Knowledge Base database schema.
+
+## Setup
+
+1. **Install dependencies**:
+   ```bash
+   pip install -r requirements_kb.txt
+   ```
+
+2. **Configure database connection**:
+   Ensure your `.env` file has PostgreSQL credentials:
+   ```
+   DB_HOST=192.168.204.65
+   DB_PORT=5432
+   DB_NAME=AI_Led_QE
+   DB_USER=genai
+   DB_PASSWORD=your_password
+   ```
+
+3. **Initialize database** (if needed):
+   ```bash
+   python -m knowledge_base.db.schema  # Creates base tables
+   ```
+
+## Running Migrations
+
+### Apply all pending migrations
+```bash
+cd /root/IGEL/IGEL_Automation_Claude/IGEL/innominds
+alembic upgrade head
+```
+
+### Check current migration status
+```bash
+alembic current
+```
+
+### View migration history
+```bash
+alembic history
+```
+
+### Rollback one migration
+```bash
+alembic downgrade -1
+```
+
+### Rollback to specific revision
+```bash
+alembic downgrade 001_phase0_feedback
+```
+
+## Creating New Migrations
+
+### Auto-generate migration (recommended)
+```bash
+alembic revision --autogenerate -m "Add new column to feedback_events"
+```
+
+### Manual migration
+```bash
+alembic revision -m "Custom schema change"
+```
+
+Then edit the generated file in `knowledge_base/alembic/versions/`.
+
+## Migration Files
+
+- `001_phase0_feedback.py` - Phase 0: Adds feedback_events, eval_runs, eval_results tables
+
+## Best Practices
+
+1. **Always test migrations in dev environment first**
+2. **Review auto-generated migrations** - Alembic may miss custom types or constraints
+3. **Include both upgrade() and downgrade()** - Always provide rollback path
+4. **Never edit applied migrations** - Create new migration instead
+5. **Backup before production migrations**:
+   ```bash
+   pg_dump -U genai AI_Led_QE > backup_$(date +%Y%m%d_%H%M%S).sql
+   ```
+
+## Troubleshooting
+
+### Migration fails with "relation already exists"
+The table may have been created by `schema.py`. Options:
+1. Drop the table: `DROP TABLE feedback_events CASCADE;`
+2. Or mark migration as applied: `alembic stamp 001_phase0_feedback`
+
+### Database connection error
+- Check `.env` file has correct credentials
+- Verify PostgreSQL is running: `psql -U genai -d AI_Led_QE -h 192.168.204.65`
+- Check network connectivity to DB server
+
+### "Can't locate revision identified by"
+Reset Alembic's version tracking:
+```bash
+# WARNING: Only in dev environment
+DROP TABLE IF EXISTS alembic_version;
+alembic stamp head
+```