igel-qe-core 1.0.3 → 1.0.7

package/dist/cli/platform.js

@@ -2,89 +2,132 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+// ── Helpers ────────────────────────────────────────────────────────────────
+/** 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);
+        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 for now */ }
-            }
-            else {
-                fs.mkdirSync(path.dirname(vscodeSettingsPath), { 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;
             }
-            if (!settings['github.copilot.chat.mcp.servers']) {
-                settings['github.copilot.chat.mcp.servers'] = {};
+            // ── 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;
             }
-            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);
-                }
-                catch (e) { /* ignore parse error */ }
-            }
-            else {
-                fs.mkdirSync(path.dirname(clineConfigPath), { recursive: true });
-            }
-            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');
-            }
-            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 */ }
-            }
-            else {
-                fs.mkdirSync(path.dirname(vscodeSettingsPath), { recursive: true });
+                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;
             }
-            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,30 @@
+#!/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() {
+    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 +33,49 @@ const server = new Server({
         tools: {}
     }
 });
+// 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',
+    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) => {
-        // 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", [
-            "-m", "knowledge_base.cli.workflow_cli",
-            "--action", workflowName,
+    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: 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 +86,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,46 +97,210 @@ 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" }));
             }
         });
     });
 }
 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)" },
+                    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 (e.g., IGEL-1234)" }
+                    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.",
@@ -119,8 +334,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "igel-qe-core",
-  "version": "1.0.3",
+  "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/src/agents/__init__.py

@@ -0,0 +1,3 @@
+"""Agent orchestration package for IGEL QE."""
+
+__all__ = []