igel-qe-core 1.0.3 → 1.0.5

package/dist/cli/platform.js

@@ -1,90 +1,145 @@
 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();
+    if (process.platform === 'win32') {
+        // Windows native install
+        return path.join(home, 'AppData', 'Roaming', 'Code', 'User', 'settings.json');
+    }
+    // Linux / macOS – try VS Code Server (remote-SSH / code-server) first
+    const vscodeServerUserSettings = path.join(home, '.vscode-server', 'data', 'User', 'settings.json');
+    if (fs.existsSync(path.dirname(vscodeServerUserSettings)) || process.env.VSCODE_SERVER_DATA_DIR) {
+        return vscodeServerUserSettings;
+    }
+    // Standard desktop VS Code on Linux
+    const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+    return path.join(xdgConfig, 'Code', 'User', 'settings.json');
+}
+/** Read JSON safely; return defaultValue on any error. */
+function readJson(filePath, defaultValue = {}) {
+    if (!fs.existsSync(filePath))
+        return defaultValue;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return defaultValue;
+    }
+}
+/** Write JSON and ensure the parent directory exists. */
+function writeJson(filePath, data) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+// ── Main export ────────────────────────────────────────────────────────────
 export async function setupPlatform(platform) {
-    const homeDir = os.homedir();
-    // The command we want to inject
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const serverJsPath = path.resolve(currentDir, '..', 'mcp', 'server.js');
+    const nodeExecutable = process.execPath || 'node';
+    // Standard MCP server entry used by most tools
     const mcpServerConfig = {
-        command: process.platform === 'win32' ? 'igel-qe-mcp.cmd' : 'igel-qe-mcp',
-        args: []
+        command: nodeExecutable,
+        args: [serverJsPath],
+    };
+    // For tools that expect { type, command, args } (e.g. VS Code .vscode/mcp.json)
+    const vscMcpServerConfig = {
+        type: 'stdio',
+        command: nodeExecutable,
+        args: [serverJsPath],
     };
     try {
-        if (platform === 'copilot') {
-            // Setup for GitHub Copilot in VS Code
-            // VS Code user settings on Windows usually live in AppData/Roaming/Code/User
-            let vscodeSettingsPath = path.join(homeDir, 'AppData', 'Roaming', 'Code', 'User', 'settings.json');
-            if (process.platform !== 'win32') {
-                vscodeSettingsPath = path.join(homeDir, '.config', 'Code', 'User', 'settings.json');
-            }
-            let settings = {};
-            if (fs.existsSync(vscodeSettingsPath)) {
-                const raw = fs.readFileSync(vscodeSettingsPath, 'utf8');
-                try {
-                    settings = JSON.parse(raw);
-                }
-                catch (e) { /* ignore parse error for now */ }
-            }
-            else {
-                fs.mkdirSync(path.dirname(vscodeSettingsPath), { recursive: true });
-            }
-            if (!settings['github.copilot.chat.mcp.servers']) {
-                settings['github.copilot.chat.mcp.servers'] = {};
-            }
-            settings['github.copilot.chat.mcp.servers']['igel-qe'] = mcpServerConfig;
-            fs.writeFileSync(vscodeSettingsPath, JSON.stringify(settings, null, 2));
-            console.log(chalk.green(`✓ Successfully configured GitHub Copilot MCP in ${vscodeSettingsPath}`));
-        }
-        else if (platform === 'cline') {
-            // Setup for Cline (Claude Dev)
-            let clineConfigPath = path.join(homeDir, 'AppData', 'Roaming', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json');
-            if (process.platform !== 'win32') {
-                clineConfigPath = path.join(homeDir, '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json');
-            }
-            let settings = { mcpServers: {} };
-            if (fs.existsSync(clineConfigPath)) {
-                const raw = fs.readFileSync(clineConfigPath, 'utf8');
-                try {
-                    settings = JSON.parse(raw);
+        switch (platform) {
+            case 'copilot': {
+                const settingsPath = detectVscodeSettingsPath();
+                // 1. VS Code global user mcp.json (Standard for VS Code Copilot MCP)
+                const globalMcpPath = path.join(path.dirname(settingsPath), 'mcp.json');
+                const globalMcp = readJson(globalMcpPath, {});
+                if (!globalMcp.mcpServers)
+                    globalMcp.mcpServers = {};
+                if (!globalMcp.servers)
+                    globalMcp.servers = {};
+                globalMcp.mcpServers['igel-qe'] = mcpServerConfig;
+                globalMcp.servers['igel-qe'] = mcpServerConfig;
+                writeJson(globalMcpPath, globalMcp);
+                console.log(chalk.green(`✓ GitHub Copilot MCP (Global) → ${globalMcpPath}`));
+                // 2. Workspace .vscode/mcp.json (works in any VS Code ≥ 1.99)
+                const workspaceMcpPath = path.join(process.cwd(), '.vscode', 'mcp.json');
+                const workspaceMcp = readJson(workspaceMcpPath, {});
+                if (!workspaceMcp.mcpServers)
+                    workspaceMcp.mcpServers = {};
+                if (!workspaceMcp.servers)
+                    workspaceMcp.servers = {};
+                workspaceMcp.mcpServers['igel-qe'] = vscMcpServerConfig;
+                workspaceMcp.servers['igel-qe'] = vscMcpServerConfig;
+                writeJson(workspaceMcpPath, workspaceMcp);
+                console.log(chalk.green(`✓ Workspace MCP config → ${workspaceMcpPath}`));
+                // 3. Fallback: VS Code user settings.json (Legacy Copilot setting)
+                const settings = readJson(settingsPath);
+                if (!settings['github.copilot.chat.mcp.servers']) {
+                    settings['github.copilot.chat.mcp.servers'] = {};
                 }
-                catch (e) { /* ignore parse error */ }
-            }
-            else {
-                fs.mkdirSync(path.dirname(clineConfigPath), { recursive: true });
+                settings['github.copilot.chat.mcp.servers']['igel-qe'] = mcpServerConfig;
+                writeJson(settingsPath, settings);
+                console.log(chalk.green(`✓ GitHub Copilot legacy MCP config → ${settingsPath}`));
+                break;
             }
-            settings.mcpServers['igel-qe'] = mcpServerConfig;
-            fs.writeFileSync(clineConfigPath, JSON.stringify(settings, null, 2));
-            console.log(chalk.green(`✓ Successfully configured Cline MCP in ${clineConfigPath}`));
-        }
-        else if (platform === 'antigravity') {
-            // Setup for Antigravity (Gemini Code Assist / AI)
-            let vscodeSettingsPath = path.join(homeDir, 'AppData', 'Roaming', 'Code', 'User', 'settings.json');
-            if (process.platform !== 'win32') {
-                vscodeSettingsPath = path.join(homeDir, '.config', 'Code', 'User', 'settings.json');
+            // ── Cline (Claude Dev) ─────────────────────────────────────────
+            case 'cline': {
+                const home = os.homedir();
+                const clineConfigPath = process.platform === 'win32'
+                    ? path.join(home, 'AppData', 'Roaming', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json')
+                    : path.join(home, '.vscode-server', 'data', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json');
+                const settings = readJson(clineConfigPath, { mcpServers: {} });
+                if (!settings.mcpServers)
+                    settings.mcpServers = {};
+                settings.mcpServers['igel-qe'] = mcpServerConfig;
+                writeJson(clineConfigPath, settings);
+                console.log(chalk.green(`✓ Cline MCP → ${clineConfigPath}`));
+                break;
             }
-            let settings = {};
-            if (fs.existsSync(vscodeSettingsPath)) {
-                const raw = fs.readFileSync(vscodeSettingsPath, 'utf8');
-                try {
-                    settings = JSON.parse(raw);
+            // ── Antigravity (Gemini Code Assist in VS Code) ────────────────
+            case 'antigravity': {
+                // 1. VS Code user settings (gemini.mcp.servers key)
+                const settingsPath = detectVscodeSettingsPath();
+                const settings = readJson(settingsPath);
+                if (!settings['gemini.mcp.servers']) {
+                    settings['gemini.mcp.servers'] = {};
                 }
-                catch (e) { /* ignore */ }
+                settings['gemini.mcp.servers']['igel-qe'] = mcpServerConfig;
+                writeJson(settingsPath, settings);
+                console.log(chalk.green(`✓ Antigravity MCP (settings.json) → ${settingsPath}`));
+                // 2. Workspace .mcp.json (the format Antigravity reads from the project root)
+                const workspaceMcpPath = path.join(process.cwd(), '.mcp.json');
+                const workspaceMcp = readJson(workspaceMcpPath, { mcpServers: {} });
+                if (!workspaceMcp.mcpServers)
+                    workspaceMcp.mcpServers = {};
+                workspaceMcp.mcpServers['igel-qe'] = mcpServerConfig;
+                writeJson(workspaceMcpPath, workspaceMcp);
+                console.log(chalk.green(`✓ Antigravity workspace MCP (.mcp.json) → ${workspaceMcpPath}`));
+                break;
             }
-            else {
-                fs.mkdirSync(path.dirname(vscodeSettingsPath), { recursive: true });
-            }
-            if (!settings['gemini.mcp.servers']) {
-                settings['gemini.mcp.servers'] = {};
-            }
-            settings['gemini.mcp.servers']['igel-qe'] = mcpServerConfig;
-            fs.writeFileSync(vscodeSettingsPath, JSON.stringify(settings, null, 2));
-            console.log(chalk.green(`✓ Successfully configured Antigravity MCP in ${vscodeSettingsPath}`));
-        }
-        else {
-            console.log(chalk.yellow(`Platform '${platform}' is not currently supported for auto-setup.`));
+            default:
+                console.log(chalk.yellow(`Platform '${platform}' is not currently supported. Supported: copilot, cline, antigravity.`));
         }
     }
     catch (err) {
-        console.error(chalk.red(`Failed to setup ${platform}: ${err.message}`));
+        console.error(chalk.red(`✗ Failed to setup ${platform}: ${err.message}`));
     }
 }

package/dist/mcp/server.js

@@ -1,10 +1,29 @@
+#!/usr/bin/env 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() {
+    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",
@@ -13,19 +32,38 @@ const server = new Server({
         tools: {}
     }
 });
+// Map MCP tool names to workflow_cli action names
+const TOOL_TO_ACTION = {
+    generate_test_cases: 'generate_test_cases',
+    generate_automation: 'generate_automation',
+    sync_bitbucket: 'sync_bitbucket',
+    impact_analysis: 'impact_analysis',
+    submit_feedback: 'submit_feedback',
+};
 async function callPythonEngine(workflowName, args) {
-    return new Promise((resolve, reject) => {
-        // Run the Python CLI in the project root
-        // We assume the environment is set up and `python` refers to the venv
-        const projectRoot = path.join(__dirname, '..', '..', '..');
-        const pythonProcess = spawn("python", [
+    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", "knowledge_base.cli.workflow_cli",
-            "--action", workflowName,
+            "--action", action,
             "--args", JSON.stringify(args)
         ], {
-            cwd: projectRoot,
-            env: process.env // Inherit the environment (.env vars)
+            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) => {
@@ -36,6 +74,7 @@ async function callPythonEngine(workflowName, args) {
             console.error(`Python stderr: ${data}`); // MCP servers use stderr for logging
         });
         pythonProcess.on("close", (code) => {
+            clearTimeout(timeout);
             if (code !== 0) {
                 // If it crashed entirely, return the stderr as a JSON error
                 resolve(JSON.stringify({
@@ -46,7 +85,8 @@ async function callPythonEngine(workflowName, args) {
             }
             else {
                 // Return the exact JSON stdout printed by workflow_cli.py
-                resolve(stdoutData.trim());
+                const output = stdoutData.trim();
+                resolve(output || JSON.stringify({ status: "error", message: "Empty output from Python engine" }));
             }
         });
     });
@@ -119,8 +159,34 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
 }));
 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: result }]
+        content: [{ type: "text", text: formattedResult }]
     };
 });
 async function main() {

package/knowledge_base/agents/__init__.py

@@ -1,6 +1,3 @@
-"""LangGraph agents package — Phase 5+."""
+"""Agent orchestration package for IGEL QE."""
 
-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"]
+__all__ = []

package/knowledge_base/agents/automation_design_agent.py

@@ -5,7 +5,7 @@ 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.embeddings.azure_embedder import embed_single
 from knowledge_base.models.test_requirement import TestCaseWithConfidence
 
 logger = logging.getLogger(__name__)
@@ -30,7 +30,7 @@ Output MUST be valid JSON matching this schema:
 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)
+        embedding = embed_single(query)
         assets = {"page_object": [], "fixture": [], "utility": [], "base_class": [], "api_client": []}
         
         with get_conn() as conn:

package/knowledge_base/agents/confidence_agent.py

@@ -78,7 +78,8 @@ def compute_hybrid_confidence(tc: GeneratedTestCase, scenario: ScenarioWithRules
     )
     
     tc.confidence_score = total
-    tc.confidence_metrics = metrics.dict()
+    # Support both Pydantic v1 (.dict()) and v2 (.model_dump())
+    tc.confidence_metrics = metrics.model_dump() if hasattr(metrics, 'model_dump') else metrics.dict()
     
     is_approved = total >= 0.80
     

package/knowledge_base/agents/feedback_agent.py

@@ -35,6 +35,10 @@ class FeedbackAgent:
             logger.error(f"Failed to capture feedback: {e}")
             return False
 
+    def submit(self, level: str, target_id: str, feedback_type: str, user_comment: str, corrected_data: Optional[Dict] = None) -> bool:
+        """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."""
         feedback = []

package/knowledge_base/agents/workflow_engine.py

@@ -21,7 +21,7 @@ class WorkflowEngine:
         self.repo_path = repo_path
         self.exec_validator = ExecutionValidationAgent(repo_path)
         
-    def run_requirement_flow(self, req: TestRequirement) -> TestRequirement:
+    def run_requirement_flow(self, req: TestRequirement) -> Tuple[TestRequirement, List]:
         """Requirement -> Requirement Understanding -> Scenario -> Business Rules"""
         logger.info(f"Starting requirement flow for {req.jira_key}")
         

package/knowledge_base/cli/workflow_cli.py

@@ -4,81 +4,123 @@ import logging
 import sys
 from pathlib import Path
 
-from knowledge_base.db.client import get_conn
+# Bootstrap: ensure the project root is in PYTHONPATH so that
+# `knowledge_base` is importable whether called via `python -m` or directly.
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
 from knowledge_base.db.igel_schema import ensure_igel_tables
 from knowledge_base.connectors.jira_connector import JiraConnector
 from knowledge_base.agents.workflow_engine import WorkflowEngine
 
-logging.basicConfig(level=logging.ERROR) # Only output strict JSON to stdout
+logging.basicConfig(level=logging.ERROR)  # Only output strict JSON to stdout
+
+ALL_ACTIONS = [
+    "generate_test_cases",
+    "generate_automation",
+    "sync_bitbucket",
+    "impact_analysis",
+    "submit_feedback",
+]
+
 
 def main():
     parser = argparse.ArgumentParser(description="Workflow CLI for Node.js IPC")
-    parser.add_argument("--action", required=True, choices=["generate_test_cases", "sync_bitbucket"])
+    parser.add_argument("--action", required=True, choices=ALL_ACTIONS)
     parser.add_argument("--args", required=True, help="JSON arguments for the action")
-    
+
     args = parser.parse_args()
-    
+
     try:
         payload = json.loads(args.args)
     except json.JSONDecodeError:
         print(json.dumps({"status": "error", "message": "Invalid JSON args"}))
         sys.exit(1)
-        
-    try:
-        ensure_igel_tables()
-    except Exception as e:
-        print(json.dumps({"status": "error", "message": f"Database Init Failed: {e}"}))
-        sys.exit(1)
-        
+
+    # ── DB init (skip for feedback which may not need it) ────────────────────
+    if args.action not in ("submit_feedback",):
+        try:
+            ensure_igel_tables()
+        except Exception as e:
+            print(json.dumps({"status": "error", "message": f"Database Init Failed: {e}"}))
+            sys.exit(1)
+
+    # ── generate_test_cases ──────────────────────────────────────────────────
     if args.action == "generate_test_cases":
         jira_key = payload.get("jira_key")
         if not jira_key:
             print(json.dumps({"status": "error", "message": "Missing jira_key"}))
             sys.exit(1)
-            
+
+        try:
+            connector = JiraConnector()
+            req = connector.get_test_requirement(jira_key)
+
+            repo_path = Path.cwd()
+            engine = WorkflowEngine(repo_path)
+
+            req, scenarios = engine.run_requirement_flow(req)
+            test_cases = engine.run_testcase_flow(req, scenarios)
+
+            result = {
+                "status": "success",
+                "jira_key": jira_key,
+                "generated_cases": len(test_cases),
+                "scenarios": [str(s) for s in scenarios],
+            }
+            print(json.dumps(result))
+
+        except Exception as e:
+            print(json.dumps({"status": "error", "message": str(e)}))
+            sys.exit(1)
+
+    # ── generate_automation ──────────────────────────────────────────────────
+    elif args.action == "generate_automation":
+        jira_key = payload.get("jira_key")
+        if not jira_key:
+            print(json.dumps({"status": "error", "message": "Missing jira_key"}))
+            sys.exit(1)
+
         try:
-            # 1. Fetch from Jira
             connector = JiraConnector()
             req = connector.get_test_requirement(jira_key)
-            
-            # 2. Run Workflow
+
             repo_path = Path.cwd()
             engine = WorkflowEngine(repo_path)
-            
+
             req, scenarios = engine.run_requirement_flow(req)
             test_cases = engine.run_testcase_flow(req, scenarios)
-            
-            # Since we skip Human Review in CLI mode, we auto-approve all for scripting
+
+            # Auto-approve all test cases for CLI automation
             for tc in test_cases:
                 tc.is_approved = True
-                
+
             output_script = repo_path / "tests" / f"test_{jira_key.replace('-', '_').lower()}.py"
             ok, msg = engine.run_script_flow(req, test_cases, output_script)
-            
+
             if ok:
                 result = {
                     "status": "success",
                     "jira_key": jira_key,
                     "generated_cases": len(test_cases),
-                    "script_path": str(output_script)
+                    "script_path": str(output_script),
                 }
             else:
-                result = {
-                    "status": "error",
-                    "message": msg
-                }
+                result = {"status": "error", "message": msg}
             print(json.dumps(result))
-            
+
         except Exception as e:
             print(json.dumps({"status": "error", "message": str(e)}))
             sys.exit(1)
-            
+
+    # ── sync_bitbucket ───────────────────────────────────────────────────────
     elif args.action == "sync_bitbucket":
         commit_hash = payload.get("commit_hash")
         if not commit_hash:
             print(json.dumps({"status": "error", "message": "Missing commit_hash"}))
             sys.exit(1)
-            
+
         try:
             from knowledge_base.agents.regression_agent import BitbucketSyncAgent
             repo_path = Path.cwd()
@@ -89,5 +131,59 @@ def main():
             print(json.dumps({"status": "error", "message": str(e)}))
             sys.exit(1)
 
+    # ── impact_analysis ──────────────────────────────────────────────────────
+    elif args.action == "impact_analysis":
+        changed_files = payload.get("changed_files")
+        if not changed_files or not isinstance(changed_files, list):
+            print(json.dumps({"status": "error", "message": "Missing or invalid changed_files list"}))
+            sys.exit(1)
+
+        try:
+            from knowledge_base.agents.regression_agent import BitbucketSyncAgent
+            repo_path = Path.cwd()
+            agent = BitbucketSyncAgent(repo_path)
+            impact = agent.analyze_impact(changed_files)
+            print(json.dumps({"status": "success", "impact": impact}))
+        except AttributeError:
+            # Fallback if analyze_impact is not yet implemented
+            print(json.dumps({
+                "status": "success",
+                "impact": {
+                    "changed_files": changed_files,
+                    "affected_tests": [],
+                    "note": "Full impact analysis requires BitbucketSyncAgent.analyze_impact implementation.",
+                },
+            }))
+        except Exception as e:
+            print(json.dumps({"status": "error", "message": str(e)}))
+            sys.exit(1)
+
+    # ── submit_feedback ──────────────────────────────────────────────────────
+    elif args.action == "submit_feedback":
+        level = payload.get("level")
+        target_id = payload.get("target_id")
+        feedback_type = payload.get("feedback_type")
+        user_comment = payload.get("user_comment", "")
+
+        if not all([level, target_id, feedback_type]):
+            print(json.dumps({"status": "error", "message": "Missing required fields: level, target_id, feedback_type"}))
+            sys.exit(1)
+
+        try:
+            from knowledge_base.agents.feedback_agent import FeedbackAgent
+            agent = FeedbackAgent()
+            result = agent.submit(
+                level=level,
+                target_id=target_id,
+                feedback_type=feedback_type,
+                user_comment=user_comment,
+            )
+            print(json.dumps({"status": "success", "result": result}))
+        except Exception as e:
+            print(json.dumps({"status": "error", "message": str(e)}))
+            sys.exit(1)
+
+
 if __name__ == "__main__":
     main()
+

package/knowledge_base/connectors/jira_connector.py

@@ -179,10 +179,6 @@ class JiraConnector(BaseConnector):
         except Exception as exc:
             logger.error(f"Failed to get test requirement {jira_key}: {exc}")
             raise
-        except Exception as exc:
-            logger.warning("JIRA sync failed: %s", exc)
-            raise
-        return items
 
     def ingest_to_kg(self, items: list[dict]) -> int:
         if not items:
@@ -220,7 +216,7 @@ class JiraConnector(BaseConnector):
                 resp = client.get(
                     f"{cfg.JIRA_URL.rstrip('/')}/rest/api/2/issue/{key}",
                     params={"fields": "summary,description,status,issuetype,comment"},
-                    auth=(cfg.JIRA_USERNAME, cfg.JIRA_API_TOKEN),
+                    **self._get_auth_kwargs(),
                 )
                 resp.raise_for_status()
                 data = resp.json()

package/knowledge_base/db/igel_schema.py

@@ -146,5 +146,5 @@ def ensure_igel_tables():
             conn.commit()
         logger.info("IGEL Enterprise DB schema verified.")
     except Exception as e:
-        logger.error(f"Failed to create IGEL schema: {{e}}")
+        logger.error(f"Failed to create IGEL schema: {e}")
         raise

package/knowledge_base/models/test_requirement.py

@@ -67,6 +67,9 @@ 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."""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "igel-qe-core",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "IGEL QE Developer Experience Layer (CLI & MCP)",
   "type": "module",
   "publishConfig": {