igel-qe-core 1.0.3 → 1.0.7

package/src/intelligence/routing_engine.py

@@ -0,0 +1,74 @@
+"""Enterprise routing score helper.
+
+Weighted decision model:
+- Complexity: 30%
+- Risk: 25%
+- Context Confidence: 20%
+- Repository Impact: 10%
+- Historical Success: 15%
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RouteInputs:
+    complexity: float
+    risk: float
+    context_confidence: float
+    repo_impact: float
+    historical_success: float
+
+
+def _clamp01(value: float) -> float:
+    return max(0.0, min(1.0, float(value)))
+
+
+def compute_weighted_score(inputs: RouteInputs) -> float:
+    c = _clamp01(inputs.complexity)
+    r = _clamp01(inputs.risk)
+    conf = _clamp01(inputs.context_confidence)
+    impact = _clamp01(inputs.repo_impact)
+    hist = _clamp01(inputs.historical_success)
+
+    # Historical success is beneficial when high, unlike risk/impact.
+    return round(
+        (0.30 * c)
+        + (0.25 * r)
+        + (0.20 * (1.0 - conf))
+        + (0.10 * impact)
+        + (0.15 * (1.0 - hist)),
+        4,
+    )
+
+
+def classify_route(score: float) -> dict:
+    """Classify route with governance actions.
+
+    Higher score => higher caution and governance.
+    """
+    s = _clamp01(score)
+    if s >= 0.70:
+        return {
+            "route_class": "small_or_medium_but_risky",
+            "planning_required": True,
+            "approval_required": True,
+            "sme_review_required": True,
+            "mode": "guarded_interactive",
+        }
+    if s >= 0.45:
+        return {
+            "route_class": "standard_controlled",
+            "planning_required": True,
+            "approval_required": True,
+            "sme_review_required": False,
+            "mode": "interactive",
+        }
+    return {
+        "route_class": "large_but_safe_or_low_risk",
+        "planning_required": False,
+        "approval_required": False,
+        "sme_review_required": False,
+        "mode": "batch_or_fast_path",
+    }

package/src/mcp/server.ts

@@ -0,0 +1,384 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+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 { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Project root: dist/mcp/server.js -> ../../ = project root
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+
+// Resolve the correct Python executable:
+// 1. Check for a local .venv with a Linux bin/ (created by python3 -m venv)
+// 2. Fall back to system python3 / python
+function resolvePythonExecutable(): string {
+    const candidates = [
+        path.join(PROJECT_ROOT, '.venv', 'bin', 'python'),
+        path.join(PROJECT_ROOT, '.venv', 'bin', 'python3'),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c)) return c;
+    }
+    // Check system python3 / python
+    return 'python3';
+}
+
+const server = new Server({
+  name: "igel-qe-mcp",
+  version: "1.0.0",
+}, {
+  capabilities: {
+    tools: {}
+  }
+});
+
+// Map MCP tool names to workflow_cli action names
+const TOOL_TO_ACTION: Record<string, string> = {
+    plan_test_cases:     'plan_test_cases',
+    generate_test_cases: 'generate_test_cases',
+    plan_automation:     'plan_automation',
+    generate_automation: 'generate_automation',
+  analyze_framework_scope: 'analyze_framework_scope',
+  project_context_cache: 'project_context_cache',
+  enrich_requirement_context: 'enrich_requirement_context',
+  enrich_framework_context: 'enrich_framework_context',
+  update_context_file: 'update_context_file',
+    sync_bitbucket:      'sync_from_commit',
+    sync_from_files:     'sync_from_files',
+    impact_analysis:     'impact_analysis',
+    submit_feedback:     'submit_feedback',
+    init_project:        'init_project',
+    sync_push_event:     'sync_push_event',
+    get_project_status:  'get_project_status',
+};
+
+async function callPythonEngine(workflowName: string, args: any): Promise<string> {
+    return new Promise((resolve, _reject) => {
+        const action = TOOL_TO_ACTION[workflowName];
+        if (!action) {
+            resolve(JSON.stringify({ status: 'error', message: `Unknown tool: ${workflowName}` }));
+            return;
+        }
+
+        const pythonExe = resolvePythonExecutable();
+        const pythonProcess = spawn(pythonExe, [
+            "-m", "src.cli.workflow_cli",
+            "--action", action,
+            "--args", JSON.stringify(args)
+        ], {
+            cwd: PROJECT_ROOT,
+            env: { ...process.env, PYTHONPATH: PROJECT_ROOT }
+        });
+
+        // Add 5-minute timeout
+        const timeout = setTimeout(() => {
+            pythonProcess.kill();
+            resolve(JSON.stringify({
+                status: "error",
+                message: "Timeout: Python process took longer than 5 minutes."
+            }));
+        }, 5 * 60 * 1000);
+
+        let stdoutData = "";
+        let stderrData = "";
+
+        pythonProcess.stdout.on("data", (data: Buffer | string) => {
+            stdoutData += data.toString();
+        });
+
+        pythonProcess.stderr.on("data", (data: Buffer | string) => {
+            stderrData += data.toString();
+            console.error(`Python stderr: ${data}`); // MCP servers use stderr for logging
+        });
+
+        pythonProcess.on("close", (code: number | null) => {
+            clearTimeout(timeout);
+            if (code !== 0) {
+                // If it crashed entirely, return the stderr as a JSON error
+                resolve(JSON.stringify({
+                    status: "error",
+                    message: `Python process exited with code ${code}`,
+                    stderr: stderrData
+                }));
+            } else {
+                // Return the exact JSON stdout printed by workflow_cli.py
+                const output = stdoutData.trim();
+                resolve(output || JSON.stringify({ status: "error", message: "Empty output from Python engine" }));
+            }
+        });
+    });
+}
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "plan_test_cases",
+      description: "Research a Jira/Xray requirement and produce a test design plan (extracted scenarios, business rules, source corroboration) without generating manual test cases. Persists the plan so generate_test_cases can reuse it.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jira_key: { type: "string", description: "The Jira issue key (e.g., IGEL-1234)" },
+          test_reqid: { type: "string", description: "Optional sub-requirement id to scope the plan under the Jira key." },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["jira_key"]
+      }
+    },
+    {
+      name: "generate_test_cases",
+      description: "Extract requirement understanding, generate business rules, and create manual test cases for a Jira/Xray issue. Reuses a plan_test_cases artifact automatically if one exists.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jira_key: { type: "string", description: "The Jira issue key (e.g., IGEL-1234)" },
+          test_reqid: { type: "string", description: "Optional sub-requirement id to scope generation under the Jira key." },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["jira_key"]
+      }
+    },
+    {
+      name: "plan_automation",
+      description: "Read the approved test cases for a Jira/Xray issue and design a reusable automation plan (page objects, fixtures, utilities from the Asset Registry) without generating or validating any script. Persists the plan so generate_automation can reuse it.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jira_key: { type: "string", description: "The Jira issue key whose approved test cases should be planned for automation." },
+          test_reqid: { type: "string", description: "Optional sub-requirement id." },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["jira_key"]
+      }
+    },
+    {
+      name: "generate_automation",
+      description: "Design an automation plan from the Asset Registry and generate pytest automation scripts for approved test cases. Reuses a plan_automation artifact automatically if one exists.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jira_key: { type: "string", description: "The Jira issue key whose approved test cases should be automated." },
+          test_reqid: { type: "string", description: "Optional sub-requirement id." },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["jira_key"]
+      }
+    },
+    {
+      name: "sync_bitbucket",
+      description: "Trigger a Delta Sync from a Bitbucket commit hash — parses changed Python files and updates the Asset Registry and Code Intelligence graphs.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          commit_hash: { type: "string", description: "The Bitbucket commit hash to sync (maps to sync_from_commit action)." }
+        },
+        required: ["commit_hash"]
+      }
+    },
+    {
+      name: "sync_from_files",
+      description: "Trigger a Delta Sync from an explicit list of changed file paths (e.g. from a local git diff).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          changed_files: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of changed file paths relative to the repo root."
+          },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["changed_files"]
+      }
+    },
+    {
+      name: "analyze_framework_scope",
+      description: "Run Diff Analyzer and scoped Framework Analyzer on changed files. Updates only impacted framework assets and dependency intelligence.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          changed_files: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of changed file paths relative to the repo root."
+          },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["changed_files"]
+      }
+    },
+    {
+      name: "project_context_cache",
+      description: "Generate .ai/context.md as a projection from DB registries and execution outcomes (context cache, not source of truth).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        }
+      }
+    },
+    {
+      name: "enrich_requirement_context",
+      description: "Update requirement context markdown and synchronize PostgreSQL requirement/asset mappings in one orchestrated call.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          jira_key: { type: "string", description: "Requirement key (e.g., QCL-1762)." },
+          context_text: { type: "string", description: "Updated context text for this requirement." },
+          changed_files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional list of changed files to seed impact mapping."
+          },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["jira_key", "context_text"]
+      }
+    },
+    {
+      name: "enrich_framework_context",
+      description: "Enrich framework context.md files using AST parsing + dependency graph extraction and persist context metadata into PostgreSQL.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          context_paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional subset of context.md paths to enrich. If omitted, enriches all discovered context.md files."
+          },
+          changed_files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional changed file paths to trigger scoped framework analyzer sync before enrichment."
+          },
+          persist_only: {
+            type: "boolean",
+            description: "When true, persists metadata/content snapshots to DB without rewriting context.md files."
+          },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        }
+      }
+    },
+    {
+      name: "update_context_file",
+      description: "Update one context.md file, regenerate AST/dependency-aware content, and write changes to PostgreSQL context registry.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          context_path: { type: "string", description: "Path to the target context.md file (relative to repo root or absolute)." },
+          changed_files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional changed file paths to re-index before regenerating context."
+          },
+          repo_path: { type: "string", description: "Optional absolute path to the local repo root." }
+        },
+        required: ["context_path"]
+      }
+    },
+    {
+      name: "init_project",
+      description: "Run pre-flight connectivity checks (PostgreSQL, Azure OpenAI, optional connectors) and scaffold the .ai/ project folder. Returns a readiness summary.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo_path: { type: "string", description: "Optional absolute path to the project root. Defaults to the server's working directory." }
+        }
+      }
+    },
+    {
+      name: "sync_push_event",
+      description: "Accept a raw Bitbucket webhook push payload, validate its HMAC signature, extract changed files, and trigger a delta sync + impact analysis.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          payload: { type: "object", description: "Raw Bitbucket push webhook payload JSON." },
+          signature: { type: "string", description: "Optional X-Hub-Signature-256 header value for HMAC validation." }
+        },
+        required: ["payload"]
+      }
+    },
+    {
+      name: "get_project_status",
+      description: "Rebuild .ai/system/ state from the database and return a project readiness summary (asset counts, connector sync status, generation history stats).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          repo_path: { type: "string", description: "Optional absolute path to the project root." }
+        }
+      }
+    },
+    {
+      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);
+  
+  // Format JSON result into nice markdown for the IDE
+  let formattedResult = result;
+  try {
+      const parsed = JSON.parse(result);
+      if (parsed.status === 'success') {
+          formattedResult = `✅ **Success**\n\n`;
+          for (const [k, v] of Object.entries(parsed)) {
+              if (k !== 'status') {
+                  if (typeof v === 'object') {
+                      formattedResult += `**${k}**:\n\`\`\`json\n${JSON.stringify(v, null, 2)}\n\`\`\`\n\n`;
+                  } else {
+                      formattedResult += `**${k}**: ${v}\n`;
+                  }
+              }
+          }
+      } else {
+          formattedResult = `❌ **Error**\n\n${parsed.message || 'Unknown error'}\n`;
+          if (parsed.stderr) formattedResult += `\n\`\`\`\n${parsed.stderr}\n\`\`\``;
+      }
+  } catch (e) {
+      // If it's not JSON, just return it directly (fallback)
+  }
+
+  return {
+    content: [{ type: "text", text: formattedResult }]
+  };
+});
+
+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/src/memory/__init__.py

@@ -0,0 +1,6 @@
+"""Operational memory layer — Phase 4 Cognee integration."""
+
+from src.memory.cognee_client import CogneeClient, get_cognee_client
+from src.memory.memory_types import MemoryType
+
+__all__ = ["CogneeClient", "get_cognee_client", "MemoryType"]

package/{knowledge_base → src}/memory/cognee_client.py

@@ -6,9 +6,9 @@ import logging
 import uuid
 from typing import Any
 
-from knowledge_base.config import cfg
-from knowledge_base.db.client import get_conn
-from knowledge_base.memory.memory_types import MemoryItem, MemoryType
+from src.config import cfg
+from src.db.client import get_conn
+from src.memory.memory_types import MemoryItem, MemoryType
 
 logger = logging.getLogger(__name__)
 

package/{knowledge_base → src}/models/test_requirement.py

@@ -67,15 +67,20 @@ class GeneratedTestCase(BaseModel):
     priority: Literal["critical", "high", "medium", "low"]
     preconditions: List[str] = Field(default_factory=list)
     steps: List[ManualTestStep] = Field(default_factory=list)
+    # Set by the confidence agent after generation
+    confidence_score: float = 0.0
+    confidence_metrics: Dict[str, Any] = Field(default_factory=dict)
     
 class ConfidenceMetrics(BaseModel):
-    """Deterministic hybrid confidence score breakdown."""
-    coverage_score: float = 0.0
-    traceability_score: float = 0.0
-    completeness_score: float = 0.0
-    historical_similarity_score: float = 0.0
-    automation_feasibility_score: float = 0.0
-    total_score: float = 0.0
+    """Deterministic two-level confidence score breakdown."""
+    context_strength: float = 0.0
+    requirement_clarity: float = 0.0
+    evidence_quality: float = 0.0
+    business_rule_coverage: float = 0.0
+    traceability_coverage: float = 0.0
+    scenario_coverage: float = 0.0
+    structural_quality: float = 0.0
+    final_confidence: float = 0.0
     
 class TestCaseWithConfidence(BaseModel):
     """Test case bundled with its validation and confidence metrics."""

package/{knowledge_base → src}/parsers/csv_parser.py

@@ -9,7 +9,7 @@ Strategy:
 from __future__ import annotations
 import re
 from pathlib import Path
-from knowledge_base.parsers.markdown_parser import Section
+from src.parsers.markdown_parser import Section
 
 
 _GROUP_COLUMNS = ["module", "component", "area", "feature", "category", "type", "status"]

package/{knowledge_base → src}/parsers/doc_parser.py

@@ -7,7 +7,7 @@ Strategy:
 from __future__ import annotations
 import re
 from pathlib import Path
-from knowledge_base.parsers.markdown_parser import Section
+from src.parsers.markdown_parser import Section
 
 
 def parse_doc(file_path: Path) -> list[Section]:

package/{knowledge_base → src}/parsers/html_parser.py

@@ -8,7 +8,7 @@ from html import unescape
 from typing import Optional
 from urllib.parse import urljoin, urlparse
 
-from knowledge_base.parsers.markdown_parser import Section
+from src.parsers.markdown_parser import Section
 
 
 @dataclass

package/{knowledge_base → src}/parsers/pdf_parser.py

@@ -9,7 +9,7 @@ PDF Parser — three-tier strategy:
 from __future__ import annotations
 import logging
 from pathlib import Path
-from knowledge_base.parsers.markdown_parser import Section, parse_markdown_file, find_markdown_for_pdf
+from src.parsers.markdown_parser import Section, parse_markdown_file, find_markdown_for_pdf
 
 logger = logging.getLogger(__name__)