igel-qe-core 1.0.0 → 1.0.2

package/dist/cli/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import chalk from "chalk";
+import { spawn } from "child_process";
+import { setupPlatform } from "./platform.js";
 const program = new Command();
 program
     .name("igel-qe")
@@ -9,7 +11,10 @@ program
 program
     .command("init")
     .description("Bootstrap the Python AI Platform Layer")
-    .action(async () => {
+    .option("--with-copilot", "Auto-configure for GitHub Copilot in VS Code")
+    .option("--with-cline", "Auto-configure for Cline")
+    .option("--with-all", "Auto-configure all supported platforms")
+    .action(async (options) => {
     console.log(chalk.blue("Initializing IGEL QE AI Platform..."));
     const steps = [
         "1. Checking Python version...",
@@ -26,13 +31,52 @@ program
         console.log(chalk.green(`  ✓ Done`));
     }
     console.log(chalk.bold.green("\nIGEL QE AI Platform successfully initialized!"));
-    console.log(`You can now use GitHub Copilot to invoke MCP tools or run commands via this CLI.`);
+    if (options.withCopilot || options.withAll) {
+        await setupPlatform('copilot');
+    }
+    if (options.withCline || options.withAll) {
+        await setupPlatform('cline');
+    }
+    console.log(`You can now use GitHub Copilot or Cline to invoke MCP tools or run commands via this CLI.`);
 });
 program
     .command("sync")
     .description("Trigger a delta sync of the automation codebase")
-    .action(() => {
-    console.log(chalk.blue("Triggering delta sync..."));
-    // Would IPC call the Python BitbucketSyncAgent
+    .option("-c, --commit <hash>", "Bitbucket commit hash to sync", "HEAD")
+    .action((options) => {
+    console.log(chalk.blue(`Triggering delta sync for commit: ${options.commit}...`));
+    import('path').then(path => {
+        import('url').then(url => {
+            const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+            const projectRoot = path.join(__dirname, '..', '..', '..');
+            const pythonProcess = spawn("python", [
+                "-m", "knowledge_base.cli.workflow_cli",
+                "--action", "sync_bitbucket",
+                "--args", JSON.stringify({ commit_hash: options.commit })
+            ], {
+                cwd: projectRoot,
+                env: process.env,
+                stdio: 'inherit'
+            });
+            pythonProcess.on("close", (code) => {
+                if (code === 0) {
+                    console.log(chalk.green("Sync completed successfully."));
+                }
+                else {
+                    console.error(chalk.red(`Sync failed with code ${code}`));
+                }
+            });
+        });
+    });
+});
+const platformCmd = program
+    .command("platform")
+    .description("Manage coding agent platform configurations");
+platformCmd
+    .command("setup <platform>")
+    .description("Setup an MCP configuration for a specific platform (copilot, cline)")
+    .action(async (platform) => {
+    console.log(chalk.blue(`Setting up configuration for ${platform}...`));
+    await setupPlatform(platform);
 });
 program.parse();

package/dist/cli/platform.js

@@ -0,0 +1,66 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import chalk from 'chalk';
+export async function setupPlatform(platform) {
+    const homeDir = os.homedir();
+    // The command we want to inject
+    const mcpServerConfig = {
+        command: process.platform === 'win32' ? 'igel-qe-mcp.cmd' : 'igel-qe-mcp',
+        args: []
+    };
+    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);
+                }
+                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 {
+            console.log(chalk.yellow(`Platform '${platform}' is not currently supported for auto-setup.`));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to setup ${platform}: ${err.message}`));
+    }
+}

package/dist/mcp/server.js

@@ -1,6 +1,7 @@
 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";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -12,16 +13,42 @@ const server = new Server({
         tools: {}
     }
 });
-// Helper to bridge to the Python AI Platform Layer
 async function callPythonEngine(workflowName, args) {
     return new Promise((resolve, reject) => {
-        // In a real implementation, this would call a unified Python IPC script
-        // For demonstration, we just return a simulated response.
-        resolve(JSON.stringify({
-            status: "success",
-            workflow: workflowName,
-            message: `Dispatched to Python AI Platform: ${workflowName}`
-        }));
+        // 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,
+            "--args", JSON.stringify(args)
+        ], {
+            cwd: projectRoot,
+            env: process.env // Inherit the environment (.env vars)
+        });
+        let stdoutData = "";
+        let stderrData = "";
+        pythonProcess.stdout.on("data", (data) => {
+            stdoutData += data.toString();
+        });
+        pythonProcess.stderr.on("data", (data) => {
+            stderrData += data.toString();
+            console.error(`Python stderr: ${data}`); // MCP servers use stderr for logging
+        });
+        pythonProcess.on("close", (code) => {
+            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
+                resolve(stdoutData.trim());
+            }
+        });
     });
 }
 server.setRequestHandler(ListToolsRequestSchema, async () => ({

package/knowledge_base/cli/workflow_cli.py

@@ -0,0 +1,93 @@
+import argparse
+import json
+import logging
+import sys
+from pathlib import Path
+
+from knowledge_base.db.client import get_conn
+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
+
+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("--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)
+        
+    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:
+            # 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
+            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)
+                }
+            else:
+                result = {
+                    "status": "error",
+                    "message": msg
+                }
+            print(json.dumps(result))
+            
+        except Exception as e:
+            print(json.dumps({"status": "error", "message": str(e)}))
+            sys.exit(1)
+            
+    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()
+            agent = BitbucketSyncAgent(repo_path)
+            agent.sync_changed_files(commit_hash)
+            print(json.dumps({"status": "success", "synced_commit": commit_hash}))
+        except Exception as e:
+            print(json.dumps({"status": "error", "message": str(e)}))
+            sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/knowledge_base/config/settings.py

@@ -219,6 +219,7 @@ class Config:
     JIRA_URL: str = os.getenv("JIRA_URL", "")
     JIRA_USERNAME: str = os.getenv("JIRA_USERNAME", "")
     JIRA_API_TOKEN: str = os.getenv("JIRA_API_TOKEN", "")
+    JIRA_OAUTH_TOKEN: str = os.getenv("JIRA_OAUTH_TOKEN", "")
 
     CONFLUENCE_ENABLED: bool = _truthy(os.getenv("CONFLUENCE_ENABLED"), False)
     CONFLUENCE_URL: str = os.getenv("CONFLUENCE_URL", "")

package/knowledge_base/connectors/jira_connector.py

@@ -45,11 +45,20 @@ class JiraConnector(BaseConnector):
     def connect(self) -> bool:
         if not self.enabled:
             return False
-        if not cfg.JIRA_URL or not cfg.JIRA_USERNAME or not cfg.JIRA_API_TOKEN:
-            logger.warning("JIRA credentials missing")
+        if not cfg.JIRA_URL:
+            logger.warning("JIRA_URL missing")
+            return False
+        if not cfg.JIRA_OAUTH_TOKEN and not (cfg.JIRA_USERNAME and cfg.JIRA_API_TOKEN):
+            logger.warning("JIRA credentials missing (no OAuth token or Basic Auth)")
             return False
         return True
 
+    def _get_auth_kwargs(self) -> dict:
+        """Return httpx kwargs for authentication (Bearer or Basic)."""
+        if cfg.JIRA_OAUTH_TOKEN:
+            return {"headers": {"Authorization": f"Bearer {cfg.JIRA_OAUTH_TOKEN}"}}
+        return {"auth": (cfg.JIRA_USERNAME, cfg.JIRA_API_TOKEN)}
+
     def search(self, query: str, limit: int = 5, timeout: float | None = None) -> list[str]:
         if not self.connect():
             return []
@@ -60,7 +69,7 @@ class JiraConnector(BaseConnector):
                 resp = client.get(
                     f"{cfg.JIRA_URL.rstrip('/')}/rest/api/2/search",
                     params={"jql": jql, "maxResults": limit, "fields": "summary"},
-                    auth=(cfg.JIRA_USERNAME, cfg.JIRA_API_TOKEN),
+                    **self._get_auth_kwargs()
                 )
                 resp.raise_for_status()
                 issues = resp.json().get("issues") or []
@@ -84,7 +93,7 @@ class JiraConnector(BaseConnector):
                 resp = client.get(
                     f"{cfg.JIRA_URL.rstrip('/')}/rest/api/2/search",
                     params={"jql": jql, "maxResults": 50, "fields": "summary,description,status,components,fixVersions,issuetype"},
-                    auth=(cfg.JIRA_USERNAME, cfg.JIRA_API_TOKEN),
+                    **self._get_auth_kwargs()
                 )
                 resp.raise_for_status()
                 for issue in resp.json().get("issues") or []:
@@ -98,6 +107,78 @@ class JiraConnector(BaseConnector):
                         "issue_type": (fields.get("issuetype") or {}).get("name"),
                         "source_type": "jira",
                     })
+                return items
+        except Exception as exc:
+            logger.warning("JIRA sync failed: %s", exc)
+            return []
+
+    def get_test_requirement(self, jira_key: str) -> 'knowledge_base.models.test_requirement.TestRequirement':
+        """Fetch a specific Jira issue and parse its manual Xray test steps."""
+        if not self.connect():
+            raise Exception("Jira is not configured or disabled.")
+            
+        # We import here to avoid circular imports during init
+        from knowledge_base.models.test_requirement import TestRequirement, TestStep
+        
+        try:
+            with httpx.Client(timeout=30.0) as client:
+                # 1. Fetch the Issue
+                resp = client.get(
+                    f"{cfg.JIRA_URL.rstrip('/')}/rest/api/2/issue/{jira_key}",
+                    **self._get_auth_kwargs()
+                )
+                resp.raise_for_status()
+                issue = resp.json()
+                fields = issue.get("fields", {})
+                
+                summary = fields.get("summary", jira_key)
+                description = _jira_text(fields.get("description"))
+                components = [c.get("name") for c in fields.get("components", []) if c.get("name")]
+                labels = fields.get("labels", [])
+                
+                # 2. Extract Test Steps
+                # Depending on the Xray configuration, steps might be in a custom field, 
+                # or require a separate API call to `/rest/raven/1.0/api/test/{issueId}/step`.
+                # We will attempt to fetch via Raven API for standard Xray.
+                steps = []
+                try:
+                    step_resp = client.get(
+                        f"{cfg.JIRA_URL.rstrip('/')}/rest/raven/1.0/api/test/{jira_key}/step",
+                        **self._get_auth_kwargs()
+                    )
+                    if step_resp.status_code == 200:
+                        xray_steps = step_resp.json()
+                        for i, s in enumerate(xray_steps):
+                            # The Xray REST API returns raw HTML or text for action/data/result
+                            steps.append(TestStep(
+                                step_number=i + 1,
+                                action=_jira_text(s.get("action")),
+                                test_data=_jira_text(s.get("data")),
+                                expected_result=_jira_text(s.get("result"))
+                            ))
+                except Exception as e:
+                    logger.warning(f"Failed to fetch Xray steps for {jira_key}: {e}")
+                    
+                # If no Xray steps found, provide a fallback stub step for the AI to process based on description
+                if not steps:
+                    steps.append(TestStep(
+                        step_number=1,
+                        action="Analyze requirement description",
+                        expected_result="System behaves as specified in description"
+                    ))
+                    
+                return TestRequirement(
+                    jira_key=jira_key,
+                    summary=summary,
+                    description=description,
+                    components=components,
+                    labels=labels,
+                    steps=steps
+                )
+                
+        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

package/package.json

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