igel-qe-core 1.0.5 → 1.0.7

package/dist/cli/platform.js

@@ -1,21 +1,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { execSync } from 'child_process';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
 // ── Helpers ────────────────────────────────────────────────────────────────
-/** Resolve the full absolute path to the igel-qe-mcp binary. */
-function resolveIgelMcpBin() {
-    try {
-        // Works on Linux/macOS; on Windows use 'where igel-qe-mcp'
-        const cmd = process.platform === 'win32' ? 'where igel-qe-mcp' : 'which igel-qe-mcp';
-        return execSync(cmd, { encoding: 'utf8' }).trim().split('\n')[0];
-    }
-    catch {
-        return process.platform === 'win32' ? 'igel-qe-mcp.cmd' : 'igel-qe-mcp';
-    }
-}
 /** Detect the user-level settings.json for the running VS Code variant. */
 function detectVscodeSettingsPath() {
     const home = os.homedir();

package/dist/mcp/server.js

@@ -1,4 +1,5 @@
 #!/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";
@@ -34,11 +35,22 @@ const server = new Server({
 });
 // Map MCP tool names to workflow_cli action names
 const TOOL_TO_ACTION = {
+    plan_test_cases: 'plan_test_cases',
     generate_test_cases: 'generate_test_cases',
+    plan_automation: 'plan_automation',
     generate_automation: 'generate_automation',
-    sync_bitbucket: 'sync_bitbucket',
+    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, args) {
     return new Promise((resolve, _reject) => {
@@ -49,7 +61,7 @@ async function callPythonEngine(workflowName, args) {
         }
         const pythonExe = resolvePythonExecutable();
         const pythonProcess = spawn(pythonExe, [
-            "-m", "knowledge_base.cli.workflow_cli",
+            "-m", "src.cli.workflow_cli",
             "--action", action,
             "--args", JSON.stringify(args)
         ], {
@@ -93,39 +105,202 @@ async function callPythonEngine(workflowName, args) {
 }
 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.",
+            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)" }
+                    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.",
+            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." }
+                    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 to parse changed Python files and update the Asset Registry and Code Intelligence graphs.",
+            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 new Bitbucket commit hash to sync." }
+                    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.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "igel-qe-core",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "IGEL QE Developer Experience Layer (CLI & MCP)",
   "type": "module",
   "publishConfig": {
@@ -8,7 +8,7 @@
   },
   "files": [
     "dist/",
-    "knowledge_base/"
+    "src/"
   ],
   "bin": {
     "igel-qe": "dist/cli/index.js",
@@ -20,12 +20,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^0.6.0",
-    "commander": "^11.1.0",
     "chalk": "^5.3.0",
+    "commander": "^11.1.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
-    "@types/node": "^20.10.0",
+    "@types/node": "^20.19.43",
     "typescript": "^5.3.2"
   }
 }

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

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

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

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

package/src/agents/confidence_agent.py

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

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

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

package/{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