igel-qe-core 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+const program = new Command();
+program
+    .name("igel-qe")
+    .description("IGEL QE Developer Experience CLI")
+    .version("1.0.0");
+program
+    .command("init")
+    .description("Bootstrap the Python AI Platform Layer")
+    .action(async () => {
+    console.log(chalk.blue("Initializing IGEL QE AI Platform..."));
+    const steps = [
+        "1. Checking Python version...",
+        "2. Creating virtual environment...",
+        "3. Installing Python dependencies...",
+        "4. Verifying PostgreSQL & pgvector...",
+        "5. Configuring MCP Server...",
+        "6. Building initial Code Index & Asset Registry..."
+    ];
+    for (const step of steps) {
+        console.log(chalk.yellow(step));
+        // Simulate step execution for demonstration
+        await new Promise(r => setTimeout(r, 500));
+        console.log(chalk.green(`  ✓ Done`));
+    }
+    console.log(chalk.bold.green("\nIGEL QE AI Platform successfully initialized!"));
+    console.log(`You can now use GitHub Copilot to invoke MCP tools or run commands via this CLI.`);
+});
+program
+    .command("sync")
+    .description("Trigger a delta sync of the automation codebase")
+    .action(() => {
+    console.log(chalk.blue("Triggering delta sync..."));
+    // Would IPC call the Python BitbucketSyncAgent
+});
+program.parse();

package/dist/mcp/server.js

@@ -0,0 +1,104 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const server = new Server({
+    name: "igel-qe-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {}
+    }
+});
+// Helper to bridge to the Python AI Platform Layer
+async function callPythonEngine(workflowName, args) {
+    return new Promise((resolve, reject) => {
+        // In a real implementation, this would call a unified Python IPC script
+        // For demonstration, we just return a simulated response.
+        resolve(JSON.stringify({
+            status: "success",
+            workflow: workflowName,
+            message: `Dispatched to Python AI Platform: ${workflowName}`
+        }));
+    });
+}
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "generate_test_cases",
+            description: "Extract requirement understanding, generate business rules, and create manual test cases for a Jira/Xray issue.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    jira_key: { type: "string", description: "The Jira issue key (e.g., IGEL-1234)" }
+                },
+                required: ["jira_key"]
+            }
+        },
+        {
+            name: "generate_automation",
+            description: "Design an automation plan from the Asset Registry and generate pytest automation scripts for approved test cases.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    jira_key: { type: "string", description: "The Jira issue key whose approved test cases should be automated." }
+                },
+                required: ["jira_key"]
+            }
+        },
+        {
+            name: "sync_bitbucket",
+            description: "Trigger a Delta Sync to parse changed Python files and update the Asset Registry and Code Intelligence graphs.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    commit_hash: { type: "string", description: "The new Bitbucket commit hash to sync." }
+                },
+                required: ["commit_hash"]
+            }
+        },
+        {
+            name: "impact_analysis",
+            description: "Analyze the regression impact of changed code assets on existing test requirements and scripts.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    changed_files: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of changed file paths."
+                    }
+                },
+                required: ["changed_files"]
+            }
+        },
+        {
+            name: "submit_feedback",
+            description: "Submit granular feedback at the requirement, scenario, test case, or test step level to improve future generations.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    level: { type: "string", enum: ["requirement", "scenario", "testcase", "teststep"] },
+                    target_id: { type: "string" },
+                    feedback_type: { type: "string", enum: ["correction", "rejection", "enhancement", "approval"] },
+                    user_comment: { type: "string" }
+                },
+                required: ["level", "target_id", "feedback_type"]
+            }
+        }
+    ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const result = await callPythonEngine(request.params.name, request.params.arguments);
+    return {
+        content: [{ type: "text", text: result }]
+    };
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("IGEL QE MCP Server running on stdio");
+}
+main().catch(console.error);

package/knowledge_base/__init__.py

@@ -0,0 +1,3 @@
+"""IGEL Knowledge Base — agentic RAG test generation."""
+
+__version__ = "3.0.0"

package/knowledge_base/agents/__init__.py

@@ -0,0 +1,6 @@
+"""LangGraph agents package — Phase 5+."""
+
+from knowledge_base.agents.graph import build_graph, generate_agentic
+from knowledge_base.agents.state import AgenticState, initial_state
+
+__all__ = ["AgenticState", "initial_state", "build_graph", "generate_agentic"]

package/knowledge_base/agents/automation_design_agent.py

@@ -0,0 +1,123 @@
+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
+
+logger = logging.getLogger(__name__)
+
+class AutomationPlan(BaseModel):
+    page_objects: List[str] = Field(default_factory=list)
+    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"]
+}
+"""
+
+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)
+        assets = {"page_object": [], "fixture": [], "utility": [], "base_class": [], "api_client": []}
+        
+        with get_conn() as conn:
+            with conn.cursor() as cur:
+                # Top 20 most similar assets overall
+                cur.execute(
+                    """
+                    SELECT asset_type, name, description, 1 - (embedding <=> %s::vector) AS similarity 
+                    FROM igel_asset_registry 
+                    ORDER BY embedding <=> %s::vector ASC 
+                    LIMIT %s
+                    """,
+                    (embedding, embedding, limit)
+                )
+                for row in cur.fetchall():
+                    asset_type, name, description, similarity = row
+                    if asset_type in assets:
+                        assets[asset_type].append(f"{name} ({description[:100]}...)")
+                        
+        return assets
+    except Exception as e:
+        logger.error(f"Semantic search failed: {e}")
+        return {"page_object": [], "fixture": [], "utility": []}
+
+def design_automation_plan(test_cases: List[TestCaseWithConfidence]) -> AutomationPlan:
+    """Generate an automation plan restricting script generation to known assets."""
+    client = _get_llm_client()
+    
+    # Filter only approved TCs
+    approved_tcs = [tc.test_case for tc in test_cases if tc.is_approved]
+    if not approved_tcs:
+        logger.warning("No approved test cases provided for automation design.")
+        return AutomationPlan()
+        
+    # Build query text from TC titles and steps
+    query_parts = []
+    for tc in approved_tcs:
+        query_parts.append(tc.title)
+        query_parts.extend([s.action for s in tc.steps])
+    
+    search_query = " ".join(query_parts)
+    
+    # Fetch potential assets from DB
+    available_assets = _semantic_search_assets(search_query)
+    
+    # Prompt construction
+    user_prompt = "Approved Test Cases to Automate:\n"
+    for tc in approved_tcs:
+        user_prompt += f"- {tc.title}\n"
+        
+    user_prompt += "\nAvailable Page Objects / API Clients:\n"
+    for p in available_assets.get("page_object", []) + available_assets.get("api_client", []):
+        user_prompt += f"- {p}\n"
+        
+    user_prompt += "\nAvailable Fixtures:\n"
+    for f in available_assets.get("fixture", []):
+        user_prompt += f"- {f}\n"
+        
+    user_prompt += "\nAvailable Utilities:\n"
+    for u in available_assets.get("utility", []):
+        user_prompt += f"- {u}\n"
+        
+    user_prompt += "\nDesign the optimal automation plan using ONLY the provided available assets."
+
+    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.1,
+            max_tokens=1000,
+        )
+        
+        content = response.choices[0].message.content or "{}"
+        data = json.loads(content)
+        
+        plan = AutomationPlan(
+            page_objects=data.get("page_objects", []),
+            fixtures=data.get("fixtures", []),
+            utilities=data.get("utilities", [])
+        )
+        logger.info(f"Designed Automation Plan with {len(plan.page_objects)} POs, {len(plan.fixtures)} fixtures")
+        return plan
+        
+    except Exception as e:
+        logger.error(f"Failed to design automation plan: {e}")
+        return AutomationPlan()

package/knowledge_base/agents/code_intelligence_agent.py

@@ -0,0 +1,147 @@
+import ast
+import hashlib
+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
+
+logger = logging.getLogger(__name__)
+
+class CodeIntelligenceAgent:
+    """Agent responsible for AST parsing and populating the Automation Asset Registry."""
+    
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        
+    def _hash_file(self, file_path: Path) -> str:
+        """Compute SHA-256 hash of a file."""
+        hasher = hashlib.sha256()
+        with open(file_path, 'rb') as f:
+            hasher.update(f.read())
+        return hasher.hexdigest()
+
+    def index_file(self, file_path: Path) -> int:
+        """Parse a Python file and index its assets (classes, functions, fixtures)."""
+        if not file_path.name.endswith(".py"):
+            return 0
+            
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+                
+            file_hash = self._hash_file(file_path)
+            rel_path = str(file_path.relative_to(self.repo_path))
+            
+            # Check if file changed
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    cur.execute(
+                        "SELECT file_hash FROM igel_asset_registry WHERE file_path = %s LIMIT 1",
+                        (rel_path,)
+                    )
+                    row = cur.fetchone()
+                    if row and row[0] == file_hash:
+                        logger.debug(f"File {rel_path} unchanged, skipping.")
+                        return 0
+                        
+                    # Delete old assets for this file before re-indexing
+                    cur.execute("DELETE FROM igel_asset_registry WHERE file_path = %s", (rel_path,))
+                conn.commit()
+
+            tree = ast.parse(content)
+            assets_found = 0
+            
+            for node in ast.walk(tree):
+                # Page Objects / API Clients / Base Classes
+                if isinstance(node, ast.ClassDef):
+                    docstring = ast.get_docstring(node) or ""
+                    asset_type = "page_object"
+                    if "Api" in node.name or "Client" in node.name:
+                        asset_type = "api_client"
+                    elif "Base" in node.name:
+                        asset_type = "base_class"
+                        
+                    self._store_asset(
+                        name=node.name,
+                        asset_type=asset_type,
+                        file_path=rel_path,
+                        description=docstring,
+                        signature=f"class {node.name}",
+                        file_hash=file_hash
+                    )
+                    assets_found += 1
+                    
+                # Fixtures / Utilities
+                elif isinstance(node, ast.FunctionDef):
+                    is_fixture = any(
+                        isinstance(d, ast.Attribute) and d.attr == "fixture" 
+                        for d in node.decorator_list
+                    ) or any(
+                        isinstance(d, ast.Call) and isinstance(d.func, ast.Attribute) and d.func.attr == "fixture"
+                        for d in node.decorator_list
+                    )
+                    
+                    if is_fixture:
+                        docstring = ast.get_docstring(node) or ""
+                        self._store_asset(
+                            name=node.name,
+                            asset_type="fixture",
+                            file_path=rel_path,
+                            description=docstring,
+                            signature=f"def {node.name}()",
+                            file_hash=file_hash
+                        )
+                        assets_found += 1
+                    elif "util" in rel_path or "helper" in rel_path:
+                        docstring = ast.get_docstring(node) or ""
+                        self._store_asset(
+                            name=node.name,
+                            asset_type="utility",
+                            file_path=rel_path,
+                            description=docstring,
+                            signature=f"def {node.name}()",
+                            file_hash=file_hash
+                        )
+                        assets_found += 1
+                        
+            logger.info(f"Indexed {assets_found} assets in {rel_path}")
+            return assets_found
+            
+        except SyntaxError as e:
+            logger.error(f"Syntax error in {file_path}: {e}")
+            return 0
+        except Exception as e:
+            logger.error(f"Failed to index {file_path}: {e}")
+            return 0
+            
+    def _store_asset(self, name: str, asset_type: str, file_path: str, description: str, signature: str, file_hash: str):
+        """Embed and store the asset in the registry."""
+        search_text = f"{asset_type} {name}\n{description}"
+        try:
+            # Vectorize the semantic description
+            embedding = get_embedding(search_text)
+            
+            with get_conn() as conn:
+                with conn.cursor() as cur:
+                    cur.execute(
+                        """
+                        INSERT INTO igel_asset_registry 
+                        (asset_type, name, file_path, description, signature, embedding, file_hash)
+                        VALUES (%s, %s, %s, %s, %s, %s::vector, %s)
+                        """,
+                        (asset_type, name, file_path, description, signature, embedding, file_hash)
+                    )
+                conn.commit()
+        except Exception as e:
+            logger.error(f"Failed to store asset {name}: {e}")
+            
+    def index_repo(self) -> int:
+        """Walk the repository and index all Python files."""
+        total_assets = 0
+        for py_file in self.repo_path.rglob("*.py"):
+            if "venv" in str(py_file) or ".tox" in str(py_file) or "node_modules" in str(py_file):
+                continue
+            total_assets += self.index_file(py_file)
+        return total_assets