artes 1.6.4 → 1.7.1

package/README.md

@@ -87,9 +87,19 @@ Artes is a test runner for Playwright that executes [predefined Cucumber tests](
 ### 🧪 CLI, CI/CD & Containerization
 
 - Powerful CLI for full control from the command line
+- Quality gate support — set a minimum success rate threshold to automatically fail the pipeline when test results drop below the required percentage
 - Official [Artes Docker image](https://hub.docker.com/r/vahidaghayev/artes) for seamless containerized execution
 - CI/CD-ready — integrate easily with any pipeline
 
+### 🤖 AI-Powered Bug Reports & Test Summaries
+
+- Automatically generates professional bug reports for failed test cases
+- Generates concise test summaries for passed scenarios
+- Supports multiple AI providers — OpenAI, Google Gemini, Anthropic Claude, Mistral, Groq, Cohere, DeepSeek (see [Supported AI Providers](docs/aiProviders.md) for full model list and setup)
+- Works with local AI models (Ollama, LM Studio) — no API key required
+- Multi-language report generation — produce reports in any language
+- Configurable report cap to control API usage and costs
+
 ### 📊 Artes Reporting System
 
 - Easy installation with docker compose (For detailed info: [Artes Reporting System](https://github.com/4gayev1/artes-reporting-system))
@@ -173,6 +183,19 @@ npx artes [options]
 | ⏱️ `--timeout`            | Set timeout for each test step in seconds (default is 30 seconds)                  | `artes --timeout 10`                                                  |
 | 🐢 `--slowMo`             | Slow down text execution for clear view (default: 0 seconds)                       | `artes --slowMo 1`                                                    |
 
+### AI Options
+
+| Option | Description | Usage Example |
+| --- | --- | --- |
+| 🤖 `--ai` | Enable AI-generated bug reports and test summaries | `artes --ai` |
+| 🧠 `--aiModel` | AI model to use for report generation | `artes --ai --aiModel "gemini 2.5 flash"` |
+| 🔑 `--aiKey` | API key for the selected AI provider | `artes --ai --aiKey "your-api-key"` |
+| 🔗 `--aiURL` | Local AI endpoint URL (e.g. Ollama, LM Studio). Overrides `--aiModel` and `--aiKey` when set | `artes --ai --aiURL "http://localhost:11434/api/chat"` |
+| 🌍 `--aiLanguage` | Language for AI-generated reports (default: `"English"`) | `artes --ai --aiLanguage "Azerbaijani"` |
+| 🔢 --maxTokens | Maximum tokens for AI response output (default: 4000) | artes --ai --maxTokens 8000 |
+| 📋 `--maxReports` | Maximum number of AI reports to generate per test run (default: `10`) | `artes --ai --maxReports 5` |
+
+
 \*\* To just run the tests: <br>
 Globally: artes <br>
 Locally: npx artes
@@ -566,6 +589,20 @@ You can configure Artes by editing the `artes.config.js` file. Below are the def
 
 ---
 
+## 🤖 AI Configuration
+
+| **Option**           | **Default Value** | **Description**                                                                                      |
+| -------------------- | ----------------- | ---------------------------------------------------------------------------------------------------- |
+| `ai.ai`              | `false`           | Enable AI-generated bug reports and test summaries.                                                  |
+| `ai.model`           | `"gpt-4o"`        | AI model to use for report generation (e.g. `"gemini 2.5 flash"`, `"claude sonnet"`)                 |
+| `ai.key`             | `""`              | API key for the selected AI provider.                                                                |
+| `ai.url`             | `""`              | Local AI endpoint URL (e.g. Ollama, LM Studio). Overrides `model` and `key` when set.                |
+| `ai.language`        | `"English"`       | Language for AI-generated reports (e.g. `"Azerbaijani"`, `"German"`).                                |
+| ai.maxTokens | 4000 | Maximum tokens for AI response output |
+| `ai.maxReports`      | `10`              | Maximum number of AI reports to generate per test run.                                               |
+
+---
+
 ## 🌍 Environment Configuration
 
 | **Option** | **Default Value** | **Description**                                                                                              |
@@ -660,8 +697,6 @@ Artes can generate Allure reports. After running tests with the `-r` flag, the r
 
 Artes has a built-in integration with the Artes Reporting System. By configuring the options below, you can automatically upload your test reports and keep your pipeline stages clean and organized.
 
-*Note: report and zip should be true for report uploading*
-
 | **Option**       | **Default Value**             | **Description**                                                        |
 | ---------------- | ----------------------------- | ---------------------------------------------------------------------- |
 | `uploadReport`   | `false`                       | Automatically upload the report to Artes Reporting System after tests. |

package/cucumber.config.js

@@ -191,6 +191,25 @@ module.exports = {
           : false,
     zip: process.env.ZIP == "true" ? true : artesConfig.zip ? true : false,
   },
+  ai:{
+ai: process.env.AI ? process.env.AI : artesConfig?.ai?.ai || false,
+url: process.env.AI_URL ? process.env.AI_URL : artesConfig?.ai?.url || "",
+model: process.env.AI_MODEL
+  ? process.env.AI_MODEL
+  : artesConfig?.ai?.model || "gpt-4o",
+key: process.env.AI_KEY
+  ? process.env.AI_KEY
+  : artesConfig?.ai?.key || "",
+language: process.env.AI_LANGUAGE
+  ? process.env.AI_LANGUAGE
+  : artesConfig?.ai?.language || "English",
+  maxTokens: process.env.MAX_TOKENS
+  ? parseInt(process.env.MAX_TOKENS)
+  : artesConfig?.ai?.maxTokens || 4000,
+maxReports: process.env.MAX_REPORTS
+  ? parseInt(process.env.MAX_REPORTS)
+  : artesConfig?.ai?.maxReports || 10,
+  },
   env: env,
   variables: loadVariables(process.env.VARS, artesConfig.variables),
   baseURL: process.env.BASE_URL

package/docs/aiProviders.md

@@ -0,0 +1,193 @@
+# 🤖 AI Providers
+
+Artes supports multiple AI providers for generating bug reports and test summaries.  
+Configure the provider via `--aiModel` flag or the `ai.model` field in artes config file.
+Use the given exact model name in cli and config file(Just copy and paste the model name).
+
+---
+
+## Supported Providers
+
+### 🔵 Google Gemini
+
+**Flag keyword:** `gemini`  
+**Get API key:** https://aistudio.google.com/app/apikey
+
+| Model Name         | `--aiModel` value       |
+|--------------------|-------------------------|
+| Gemini 2.5 Flash ⭐ | `"gemini 2.5 flash"`    |
+| Gemini 2.5 Flash Lite | `"gemini 2.5 flash lite"` |
+| Gemini 2.5 Pro     | `"gemini 2.5 pro"`      |
+| Gemini 2.0 Flash   | `"gemini 2.0 flash"`    |
+
+```bash
+artes --ai --aiModel "gemini 2.5 flash" --aiKey "your-key"
+```
+
+---
+
+### 🟢 OpenAI
+
+**Flag keyword:** `openai`, `chatgpt`, `gpt`  
+**Get API key:** https://platform.openai.com/api-keys
+
+| Model Name      | `--aiModel` value   |
+|-----------------|---------------------|
+| GPT-4o ⭐        | `"gpt-4o"`          |
+| GPT-4o Mini     | `"gpt-4o mini"`     |
+| GPT-4 Turbo     | `"gpt-4 turbo"`     |
+| GPT-4           | `"gpt-4"`           |
+| GPT-3.5 Turbo   | `"gpt-3.5 turbo"`   |
+| o1 Mini         | `"o1 mini"`         |
+| o1              | `"o1"`              |
+
+```bash
+artes --ai --aiModel "gpt-4o" --aiKey "your-key"
+```
+
+---
+
+### 🟠 Anthropic Claude
+
+**Flag keyword:** `claude`, `anthropic`  
+**Get API key:** https://console.anthropic.com/settings/keys
+
+| Model Name       | `--aiModel` value    |
+|------------------|----------------------|
+| Claude Sonnet ⭐  | `"claude sonnet"`    |
+| Claude Sonnet 4  | `"claude sonnet 4"`  |
+| Claude Opus      | `"claude opus"`      |
+| Claude Opus 4    | `"claude opus 4"`    |
+| Claude Haiku     | `"claude haiku"`     |
+
+```bash
+artes --ai --aiModel "claude sonnet" --aiKey "your-key"
+```
+
+---
+
+### 🔴 Mistral
+
+**Flag keyword:** `mistral`  
+**Get API key:** https://console.mistral.ai/api-keys
+
+| Model Name      | `--aiModel` value     |
+|-----------------|-----------------------|
+| Mistral Large ⭐ | `"mistral large"`     |
+| Mistral Medium  | `"mistral medium"`    |
+| Mistral Small   | `"mistral small"`     |
+| Mistral Nemo    | `"mistral nemo"`      |
+| Mistral 7B      | `"mistral 7b"`        |
+
+```bash
+artes --ai --aiModel "mistral large" --aiKey "your-key"
+```
+
+---
+
+### ⚡ Groq
+
+**Flag keyword:** `groq`  
+**Get API key:** https://console.groq.com/keys
+
+| Model Name        | `--aiModel` value       |
+|-------------------|-------------------------|
+| LLaMA 3 70B ⭐    | `"groq llama 3 70b"`    |
+| LLaMA 3 8B        | `"groq llama 3 8b"`     |
+| Mixtral 8x7B      | `"groq mixtral"`        |
+| Gemma 7B          | `"groq gemma 7b"`       |
+
+```bash
+artes --ai --aiModel "groq llama 3 70b" --aiKey "your-key"
+```
+
+---
+
+### 🔷 Cohere
+
+**Flag keyword:** `cohere`, `command`  
+**Get API key:** https://dashboard.cohere.com/api-keys
+
+| Model Name      | `--aiModel` value    |
+|-----------------|----------------------|
+| Command R+ ⭐   | `"cohere r+"`        |
+| Command R       | `"cohere r"`         |
+
+```bash
+artes --ai --aiModel "cohere r+" --aiKey "your-key"
+```
+
+---
+
+### 🐋 DeepSeek
+
+**Flag keyword:** `deepseek`  
+**Get API key:** https://platform.deepseek.com/api_keys
+
+| Model Name       | `--aiModel` value       |
+|------------------|-------------------------|
+| DeepSeek Chat ⭐  | `"deepseek chat"`       |
+| DeepSeek Coder   | `"deepseek coder"`      |
+
+```bash
+artes --ai --aiModel "deepseek chat" --aiKey "your-key"
+```
+
+---
+
+### 🏠 Local AI (Ollama, LM Studio, etc.)
+
+Run any local model without an API key using `--aiURL` instead of `--aiModel` and `--aiKey`.  
+The endpoint must be OpenAI-compatible (accepts `messages` array in the request body).
+
+```bash
+# Ollama
+artes --ai --aiURL "http://localhost:11434/api/chat"
+
+# LM Studio
+artes --ai --aiURL "http://localhost:1234/v1/chat/completions"
+```
+
+---
+
+## Config File Usage
+
+Instead of CLI flags, you can set AI options in your `artes.config.js`:
+
+```js
+module.exports = {
+  ai: {
+    ai        : true,
+    model     : "gemini 2.5 flash",
+    key       : "your-api-key",
+    language  : "English",
+    maxReports: 10,
+
+    // For local AI — overrides model and key when set:
+    // url: "http://localhost:11434/api/chat",
+  },
+};
+```
+
+---
+
+## Environment Variables
+
+All AI options can also be set via environment variables:
+
+| Variable        | Description                              |
+|-----------------|------------------------------------------|
+| `AI`            | Enable AI reports (`true` / `false`)     |
+| `AI_MODEL`      | Model string (e.g. `"gemini 2.5 flash"`) |
+| `AI_KEY`        | API key for the provider                 |
+| `AI_URL`        | Local AI endpoint URL                    |
+| `AI_LANGUAGE`   | Report language (e.g. `"Azerbaijani"`)   |
+| `MAX_REPORTS`   | Max reports per run (e.g. `10`)          |
+
+```bash
+AI=true AI_MODEL="gpt-4o" AI_KEY="your-key" npx artes
+```
+
+---
+
+> ⭐ = default model for that provider

package/executer.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 const {
   showHelp,
+  showAIHelp,
   showVersion,
   createProject,
   runTests,
@@ -20,7 +21,6 @@ const {
 const { getEnvInfo } = require("artes/src/helper/controller/getEnvInfo");
 const { uploadReport } = require("./src/helper/controller/reportUploader");
 
-
 const artesConfigPath = path.resolve(process.cwd(), "artes.config.js");
 
 let artesConfig = {};
@@ -56,6 +56,14 @@ const flags = {
   projectName: args.includes("--projectName"),
   projectType: args.includes("--projectType"),
   reportPath: args.includes("--reportPath"),
+  aiHelp: args.includes("--aiHelp"),
+  ai: args.includes("--ai"),
+  aiURL: args.includes("--aiURL"),
+  aiModel: args.includes("--aiModel"),
+  aiKey: args.includes("--aiKey"),
+  aiLanguage: args.includes("--aiLanguage"),
+  maxTokens: args.includes("--maxTokens"),
+  maxReports: args.includes("--maxReports"),
   features: args.includes("--features"),
   stepDef: args.includes("--stepDef"),
   tags: args.includes("--tags"),
@@ -87,6 +95,13 @@ const reportPath = getArgValue("--reportPath");
 const logo = getArgValue("--logo");
 const brandName = getArgValue("--brandName");
 const reportName = getArgValue("--reportName");
+const ai = args.includes("--ai");
+const aiURL = getArgValue("--aiURL");
+const aiModel = getArgValue("--aiModel");
+const aiKey = getArgValue("--aiKey");
+const aiLanguage = getArgValue("--aiLanguage");
+const maxTokens = getArgValue("--maxTokens")
+const maxReports = getArgValue("--maxReports");
 const featureFiles = getArgValue("--features");
 const features = flags.features && featureFiles;
 const stepDef = getArgValue("--stepDef");
@@ -145,6 +160,14 @@ flags.singleFileReport
 
 flags.zip ? (process.env.ZIP = true) : (process.env.ZIP = false);
 
+flags.ai ? (process.env.AI = ai) : (process.env.AI = false);
+flags.aiURL ? (process.env.AI_URL = aiURL) : "";
+flags.aiModel ? (process.env.AI_MODEL = aiModel) : "";
+flags.aiKey ? (process.env.AI_KEY = aiKey) : "";
+flags.aiLanguage ? (process.env.AI_LANGUAGE = aiLanguage) : "";
+flags.maxTokens ? (process.env.MAX_TOKENS = maxTokens) : "";
+flags.maxReports ? (process.env.MAX_REPORTS = maxReports) : "";
+
 flags.headless &&
   console.log("Running mode:", flags.headless ? "headless" : "headed");
 flags.headless ? (process.env.MODE = JSON.stringify(true)) : false;
@@ -186,6 +209,7 @@ flags.slowMo ? (process.env.SLOWMO = slowMo) : "";
 
 async function main() {
   if (flags.help) return showHelp();
+  if (flags.aiHelp) return showAIHelp();
   if (flags.version) return showVersion();
   if (flags.create) return createProject(flags.createYes, flags.noDeps);
 
@@ -193,7 +217,7 @@ async function main() {
 
   const testCoverage = testCoverageCalculator();
 
-  if (testCoverage?.totalTests === 0) {
+  if (testCoverage.totalTests === 0) {
     console.log("\x1b[33mNo tests were run (0 scenarios). Skipping report generation and upload.\x1b[0m");
     cleanUp();
     process.exit(process.env.EXIT_CODE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.6.4",
+  "version": "1.7.1",
   "description": "The simplest way to automate UI and API tests using Cucumber-style steps.",
   "main": "index.js",
   "scripts": {

package/src/helper/controller/aiBugReporter.js

@@ -0,0 +1,349 @@
+
+
+require("allure-cucumberjs");
+const allure = require("allure-js-commons");
+
+const { PROVIDERS } = require("./aiProvider");
+
+
+function resolveProvider(aiFlag = "gemini 2.5 flash") {
+  const flag = aiFlag.trim().toLowerCase();
+
+  const provider = PROVIDERS.find((p) =>
+    p.keywords.some((kw) => flag.includes(kw))
+  );
+
+  if (!provider) {
+    console.warn(` Unknown AI provider "${aiFlag}" — falling back to Gemini.`);
+    return { provider: PROVIDERS[0], modelId: PROVIDERS[0].models.default };
+  }
+
+
+  const modelKey = Object.keys(provider.models)
+    .filter((k) => k !== "default")
+    .sort((a, b) => b.length - a.length)   
+    .find((k) => flag.includes(k));
+
+  const modelId = modelKey ? provider.models[modelKey] : provider.models.default;
+
+  return { provider, modelId };
+}
+
+
+async function callAI({ prompt, aiFlag, apiKey, maxTokens }) {
+  const { provider, modelId } = resolveProvider(aiFlag);
+  
+  const url  = provider.buildUrl(modelId, apiKey);
+  const body = provider.buildBody(prompt, modelId, maxTokens);
+
+  const headers = { "Content-Type": "application/json" };
+
+  if (provider.authStyle === "header") {
+    headers[provider.authKey] = provider.authValue(apiKey);
+  }
+
+  if (provider.buildExtraHeaders) {
+    Object.assign(headers, provider.buildExtraHeaders());
+  }
+
+  const res = await fetch(url, {
+    method : "POST",
+    headers,
+    body   : JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`${provider.name} API error ${res.status}: ${err}`);
+  }
+
+  const data = await res.json();
+  const text = provider.parseResp(data);
+
+  if (!text) throw new Error(`${provider.name} returned an empty response`);
+
+  return text.trim();
+}
+
+
+function stripAnsi(str = "") {
+
+  return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+
+const DUMMY_NAMES = new Set([
+  "alma", "test", "scenario", "example", "untitled",
+  "sample", "demo", "placeholder", "temp", "tmp",
+]);
+
+function isMeaningfulName(name = "") {
+  return !DUMMY_NAMES.has(name.trim().toLowerCase());
+}
+
+
+function buildResultContext(result = {}) {
+  const raw    = stripAnsi(result.message ?? "");
+  const exType = result.exception?.type ?? "Error";
+  const exMsg  = stripAnsi(result.exception?.message ?? raw);
+  const stack  = stripAnsi(result.exception?.stackTrace ?? "");
+
+  const expectedMatch = raw.match(/Expected[:\s]+(.+)/);
+  const receivedMatch = raw.match(/Received[:\s]+(.+)/);
+
+  return {
+    errorType   : exType,
+    errorMessage: exMsg,
+    expected    : expectedMatch ? expectedMatch[1].trim() : null,
+    received    : receivedMatch ? receivedMatch[1].trim() : null,
+    stackTrace  : stack,
+    durationMs  : result.duration
+      ? (result.duration.seconds * 1000 + result.duration.nanos / 1e6).toFixed(1)
+      : null,
+  };
+}
+
+function buildPickleContext(pickle = {}) {
+  const steps      = (pickle.steps ?? []).map((s) => s.text ?? "");
+  const failedStep = steps.at(-1) ?? null;
+
+  return {
+    scenarioName     : pickle.name ?? "Unnamed scenario",
+    featureFile      : pickle.uri  ?? null,
+    steps,
+    failedStep,
+    useMeaningfulName: isMeaningfulName(pickle.name),
+  };
+}
+
+async function callLocalAI({ prompt, url, apiKey }) {
+
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      messages: [{ role: "user", content: prompt }],
+    }),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Local AI error ${res.status}: ${err}`);
+  }
+
+  const data = await res.json();
+
+
+  const text =
+    data?.choices?.[0]?.message?.content ||
+    data?.response ||
+    data?.content ||
+    data?.text;
+
+  if (!text) throw new Error("Local AI returned an empty response");
+
+  return text.trim();
+}
+
+
+async function generateFailedBugReport({ resultCtx, pickleCtx, response, language, aiFlag, apiKey, url }) {
+
+  const nameInstruction = pickleCtx.useMeaningfulName
+    ? `The test case is named "${pickleCtx.scenarioName}" — use this as context for the bug report title.`
+    : `The test case name "${pickleCtx.scenarioName}" is a placeholder — do NOT use it; derive the title from the actual failure.`;
+
+  const prompt = `
+You are a senior QA engineer writing a professional bug report with formal language and like human written.
+Write the entire report in ${language ?? "English"}.
+Translate ALL section headings into ${language ?? "English"} — do not leave any heading in English.
+
+${nameInstruction}
+
+━━━ TEST SCENARIO ━━━
+Feature file : ${pickleCtx.featureFile ?? "unknown"}
+Scenario     : ${pickleCtx.scenarioName}
+
+Steps in this scenario:
+${pickleCtx.steps.map((s, i) => `  ${i + 1}. ${s}`).join("\n")}
+
+Failed step  : ${pickleCtx.failedStep ?? "unknown"}
+
+━━━ ASSERTION FAILURE ━━━
+Error type   : ${resultCtx.errorType}
+Error message: ${resultCtx.errorMessage}
+Expected     : ${resultCtx.expected ?? "see error message"}
+Received     : ${resultCtx.received ?? "see error message"}
+Duration     : ${resultCtx.durationMs ? resultCtx.durationMs + " ms" : "unknown"}
+
+━━━ API RESPONSE ━━━
+${JSON.stringify(response ?? {}, null, 2)}
+
+━━━ FAILED REQUEST cURL ━━━
+${response["cURL Command"]}
+
+━━━ INSTRUCTIONS ━━━
+Write a bug report with these exact sections in this order.
+Translate ALL section headings below into ${language ?? "English"} — do not leave any heading in English.
+Do NOT add extra sections. Do NOT use markdown — plain text only.
+
+BUG REPORT NAME
+(One concise sentence describing the defect — derive from the failure, not the test name if it is a placeholder)
+
+SUMMARY
+(2–4 sentences: what the test was doing, what assertion failed, and why this is a problem)
+
+ACTUAL RESULT
+(What the API/system actually did — status code, response body key points)
+
+EXPECTED RESULT
+(What it should have done according to the test assertion)
+
+STEPS TO REPRODUCE
+(Numbered list — use the scenario steps above; make each step actionable and clear)
+
+FAILED REQUEST
+(Paste the cURL command exactly as provided above)
+`.trim();
+
+
+if (url) {
+    return callLocalAI({ prompt, url, apiKey });
+  }
+
+  return callAI({ prompt, aiFlag, apiKey, maxTokens });
+}
+
+async function generatePassedSummary({ pickleCtx, response, language, aiFlag, apiKey, url }) {
+  const lang = language ?? "English";
+
+  const prompt = [
+    `You are a senior QA engineer writing a short test execution summary for your team.`,
+    `Write the entire summary in ${lang}.`,
+    `Keep it concise. No bullet soup, no corporate filler.`,
+    ``,
+    `TEST SCENARIO`,
+    `Feature file : ${pickleCtx.featureFile ?? "unknown"}`,
+    `Scenario     : ${pickleCtx.scenarioName}`,
+    ``,
+    `Steps executed:`,
+    ...pickleCtx.steps.map((s, i) => `  ${i + 1}. ${s}`),
+    ``,
+    `API RESPONSE`,
+    JSON.stringify(response ?? {}, null, 2),
+    ``,
+    `INSTRUCTIONS`,
+    `Write a short passed test summary with these exact sections in this order.`,
+    `Do NOT add extra sections. Do NOT use markdown — plain text only.`,
+    `Use these exact translated headings — do not change them, do not revert to English.`,
+    ``,
+    `Test Name`,
+    `One sentence: the name or purpose of this test case. Derive it from the steps if the scenario name is generic.`,
+    ``,
+    `Test Purpose`,
+    `1-2 sentences: what behaviour this test case is verifying and why it matters.`,
+    ``,
+    `Summary`,
+    `2-3 sentences: what happened during execution — which endpoint was called, what data was used,`,
+    `what the API returned, and that all assertions passed. Be specific about status codes and key response fields.`,
+  ].join("\n");
+
+  if (url) {
+    return callLocalAI({ prompt, url, apiKey });
+  }
+
+  return callAI({ prompt, aiFlag, apiKey, maxTokens });
+}
+
+
+
+
+let _reportCount = 0;
+
+
+
+const DEFAULT_DELAY_MS = 3000;
+
+async function attachAiBugReport({
+  result,
+  pickle,
+  response,
+  language = "English",
+  aiModel,
+  aiKey,
+  url,
+  maxReports = 10,
+  delayMs = DEFAULT_DELAY_MS,  
+  maxTokens
+}) {
+  try {
+    if (!aiKey && !url) {
+      console.warn("⚠️  No AI key or local URL provided. Skipping bug report.");
+      return;
+    }
+
+    if (_reportCount >= maxReports) {
+      console.warn(`⚠️  AI bug report cap reached (${maxReports}). Skipping "${pickle.name}".`);
+      return;
+    }
+
+    if (_reportCount > 0 && delayMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+
+    const pickleCtx = buildPickleContext(pickle);
+
+    let reportText;
+    let attachmentLabel;
+
+    if (result?.status === "PASSED") {
+      reportText = await generatePassedSummary({
+        pickleCtx,
+        response,
+        language,
+        aiFlag: aiModel,
+        apiKey: aiKey,
+        url,
+        maxTokens
+      });
+      attachmentLabel = "Test Summary";
+    } else {
+      const resultCtx = buildResultContext(result);
+      reportText = await generateFailedBugReport({
+        resultCtx,
+        pickleCtx,
+        response,
+        language,
+        aiFlag: aiModel,
+        apiKey: aiKey,
+        url,
+        maxTokens 
+      });
+      attachmentLabel = "Bug Report";
+    }
+
+    if (!reportText) return;
+
+    _reportCount++;
+
+    await allure.attachment(attachmentLabel, reportText, "text/plain");
+
+  } catch (err) {
+    console.warn("⚠️ Bug report generation failed:", err.message);
+  }
+}
+
+
+function resetReportCount() {
+  _reportCount = 0;
+}
+
+
+module.exports = {
+  attachAiBugReport,
+  buildResultContext,
+  buildPickleContext,
+  resolveProvider,
+  resetReportCount,
+};

package/src/helper/controller/aiProvider.js

@@ -0,0 +1,162 @@
+const PROVIDERS = [
+  {
+    name    : "Gemini",
+    keywords: ["gemini"],
+    models  : {
+      "2.5 flash lite" : "gemini-2.5-flash-lite",
+      "2.5 flash"      : "gemini-2.5-flash",
+      "2.5 pro"        : "gemini-2.5-pro",
+      "2.0 flash"      : "gemini-2.0-flash",
+      default          : "gemini-2.5-flash",
+    },
+    authStyle : "queryparam",
+    buildUrl  : (modelId, apiKey) =>
+      `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent?key=${apiKey}`,
+    buildBody : (prompt, modelId, maxTokens = 4000) => ({
+      contents        : [{ parts: [{ text: prompt }] }],
+      generationConfig: { temperature: 0.6, maxOutputTokens: maxTokens },
+    }),
+    parseResp : (data) => data?.candidates?.[0]?.content?.parts?.[0]?.text ?? "",
+  },
+
+  {
+    name    : "OpenAI",
+    keywords: ["openai", "chatgpt", "gpt"],
+    models  : {
+      "4o mini"   : "gpt-4o-mini",
+      "4o"        : "gpt-4o",
+      "4 turbo"   : "gpt-4-turbo",
+      "4"         : "gpt-4",
+      "3.5 turbo" : "gpt-3.5-turbo",
+      "o1 mini"   : "o1-mini",
+      "o1"        : "o1-preview",
+      default     : "gpt-4o",
+    },
+    authStyle : "header",
+    authKey   : "Authorization",
+    authValue : (apiKey) => `Bearer ${apiKey}`,
+    buildUrl  : () => "https://api.openai.com/v1/chat/completions",
+    buildBody : (prompt, modelId, maxTokens = 4000) => ({
+      model      : modelId,
+      max_tokens : maxTokens,
+      temperature: 0.6,
+      messages   : [{ role: "user", content: prompt }],
+    }),
+    parseResp : (data) => data?.choices?.[0]?.message?.content ?? "",
+  },
+
+  {
+    name    : "Claude",
+    keywords: ["claude", "anthropic"],
+    models  : {
+      "opus 4"   : "claude-opus-4-5",
+      "sonnet 4" : "claude-sonnet-4-5",
+      "haiku"    : "claude-haiku-4-5-20251001",
+      "opus"     : "claude-opus-4-5",
+      "sonnet"   : "claude-sonnet-4-5",
+      default    : "claude-sonnet-4-5",
+    },
+    authStyle        : "header",
+    authKey          : "x-api-key",
+    authValue        : (apiKey) => apiKey,
+    buildExtraHeaders: () => ({ "anthropic-version": "2023-06-01" }),
+    buildUrl         : () => "https://api.anthropic.com/v1/messages",
+    buildBody        : (prompt, modelId, maxTokens = 4000) => ({
+      model     : modelId,
+      max_tokens: maxTokens,
+      messages  : [{ role: "user", content: prompt }],
+    }),
+    parseResp : (data) =>
+      (data?.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join(""),
+  },
+
+  {
+    name    : "Mistral",
+    keywords: ["mistral"],
+    models  : {
+      "large"  : "mistral-large-latest",
+      "medium" : "mistral-medium-latest",
+      "small"  : "mistral-small-latest",
+      "nemo"   : "open-mistral-nemo",
+      "7b"     : "open-mistral-7b",
+      default  : "mistral-large-latest",
+    },
+    authStyle : "header",
+    authKey   : "Authorization",
+    authValue : (apiKey) => `Bearer ${apiKey}`,
+    buildUrl  : () => "https://api.mistral.ai/v1/chat/completions",
+    buildBody : (prompt, modelId, maxTokens = 4000) => ({
+      model      : modelId,
+      max_tokens : maxTokens,
+      temperature: 0.6,
+      messages   : [{ role: "user", content: prompt }],
+    }),
+    parseResp : (data) => data?.choices?.[0]?.message?.content ?? "",
+  },
+
+  {
+    name    : "Groq",
+    keywords: ["groq"],
+    models  : {
+      "llama 3 70b" : "llama3-70b-8192",
+      "llama 3 8b"  : "llama3-8b-8192",
+      "mixtral"     : "mixtral-8x7b-32768",
+      "gemma 7b"    : "gemma-7b-it",
+      default       : "llama3-70b-8192",
+    },
+    authStyle : "header",
+    authKey   : "Authorization",
+    authValue : (apiKey) => `Bearer ${apiKey}`,
+    buildUrl  : () => "https://api.groq.com/openai/v1/chat/completions",
+    buildBody : (prompt, modelId, maxTokens = 4000) => ({
+      model      : modelId,
+      max_tokens : maxTokens,
+      temperature: 0.6,
+      messages   : [{ role: "user", content: prompt }],
+    }),
+    parseResp : (data) => data?.choices?.[0]?.message?.content ?? "",
+  },
+
+  {
+    name    : "Cohere",
+    keywords: ["cohere", "command"],
+    models  : {
+      "r+" : "command-r-plus",
+      "r"  : "command-r",
+      default: "command-r-plus",
+    },
+    authStyle : "header",
+    authKey   : "Authorization",
+    authValue : (apiKey) => `Bearer ${apiKey}`,
+    buildUrl  : () => "https://api.cohere.com/v2/chat",
+    buildBody : (prompt, modelId, maxTokens = 4000) => ({
+      model         : modelId,
+      max_tokens    : maxTokens,
+      messages      : [{ role: "user", content: prompt }],
+    }),
+    parseResp : (data) => data?.message?.content?.[0]?.text ?? "",
+  },
+
+  {
+    name    : "DeepSeek",
+    keywords: ["deepseek"],
+    models  : {
+      "coder" : "deepseek-coder",
+      "chat"  : "deepseek-chat",
+      default : "deepseek-chat",
+    },
+    authStyle : "header",
+    authKey   : "Authorization",
+    authValue : (apiKey) => `Bearer ${apiKey}`,
+    buildUrl  : () => "https://api.deepseek.com/chat/completions",
+    buildBody : (prompt, modelId, maxTokens = 4000) => ({
+      model      : modelId,
+      max_tokens : maxTokens,
+      temperature: 0.6,
+      messages   : [{ role: "user", content: prompt }],
+    }),
+    parseResp : (data) => data?.choices?.[0]?.message?.content ?? "",
+  },
+];
+
+module.exports = { PROVIDERS };

package/src/helper/controller/getEnvInfo.js

@@ -55,6 +55,14 @@ async function getEnvInfo() {
     Parallel_Runner: cucumberConfig.default.parallel,
     Timeout: cucumberConfig.default.timeout ?? "N/A",
 
+    // ── AI Config ─────────────────────────
+    AI_Enabled:      cucumberConfig.default.ai        ?? false,
+    AI_URL:          cucumberConfig.default.url        ?? "N/A",
+    AI_Model:        cucumberConfig.default.model      ?? "gemini 2.5 flash",
+    AI_Language:     cucumberConfig.default.language   ?? "English",
+    AI_Max_Tokens:   cucumberConfig.default.maxTokens  ?? "4000",
+    AI_Max_Reports:  cucumberConfig.default.maxReports ?? 10,
+
     // ── Git ─────────────────────────────────
     Git_Branch: process.env.GIT_BRANCH ?? process.env.BRANCH_NAME ?? "N/A",
     Git_Commit: process.env.GIT_COMMIT ?? process.env.GIT_SHA ?? "N/A",

package/src/helper/controller/testCoverageCalculator.js

@@ -68,7 +68,7 @@ function testCoverageCalculator({ silent = false } = {}) {
   });
 
   if (!silent && retriedTests.length > 0) {
-    console.warn(`\n\x1b[33mRetried test cases (${retriedTests.length} test cases):`);
+    console.warn("\n\x1b[33mRetried test cases:");
     retriedTests.forEach((t) => {
       console.warn(`- "${t.scenario}" ran ${t.count} times`);
     });

package/src/helper/executers/exporter.js

@@ -1,4 +1,4 @@
-const { showHelp } = require("./helper");
+const { showHelp, showAIHelp } = require("./helper");
 const { createProject } = require("./projectCreator");
 const { generateReport } = require("./reportGenerator");
 const { runTests } = require("./testRunner");
@@ -10,6 +10,7 @@ module.exports = {
   generateReport,
   runTests,
   showHelp,
+  showAIHelp,
   showVersion,
   cleanUp,
 };

package/src/helper/executers/helper.js

@@ -129,6 +129,40 @@ function showHelp() {
       `);
 }
 
+
+function showAIHelp() {
+  console.log(`
+        🚀 Artes AI Bug reporter
+      
+        Usage: 
+            npx artes [options]
+      
+        Options:
+
+            🤖 --ai            Enable AI-generated bug reports and test summaries
+                Usage:   artes --ai
+
+            🧠 --aiModel       AI model to use for report generation
+                               Supported: "gpt-4o", "gemini 2.5 flash", "claude sonnet", "mistral large"
+                Usage:   artes --ai --aiModel "gemini 2.5 flash"
+
+            🔑 --aiKey         API key for the selected AI provider
+                Usage:   artes --ai --aiKey "your-api-key"
+
+            🔗 --aiURL         Local AI endpoint URL (e.g., Ollama, LM Studio). Overrides --aiModel and --aiKey when set
+                Usage:   artes --ai --aiURL "http://localhost:11434/api/chat"
+
+            🌍 --aiLanguage    Language for AI-generated reports (default: "English")
+                Usage:   artes --ai --aiLanguage "Azerbaijani"
+               
+            🔢 --maxTokens     Maximum tokens for AI-generated reports (default: 4000)
+                Usage:   artes --ai --maxTokens 8000
+
+            📋 --maxReports    Maximum number of AI reports to generate per test run (default: 10)
+                Usage:   artes --ai --maxReports 5
+      `);
+}
+
 module.exports = {
-  showHelp,
+  showHelp, showAIHelp
 };

package/src/helper/executers/projectCreator.js

@@ -52,6 +52,15 @@ function createProject(createYes, noDeps) {
     // paths: [],                    // string[] - Paths to feature files
     // steps: "",                    // string - Step definitions files
     // pomPath: "",                  // string - Path to POM files
+    // ai: {
+    //   ai: false,                  // boolean - Enable AI-generated bug reports and test summaries
+    //   url: "",                    // string  - Local AI endpoint URL (e.g., Ollama, LM Studio). Overrides model/key when set
+    //   model: "gemini 2.5 flash",  // string  - AI model to use (e.g., "gpt-4o", "gemini 2.5 flash", "claude sonnet", "mistral large")
+    //   key: "",                    // string  - API key for the selected AI provider
+    //   language: "English",        // string  - Language for generated reports (e.g., "English", "Azerbaijani"),
+    //   maxTokens: 4000,            // number  - Maximum tokens for AI-generated reports (default: 4000)
+    //   maxReports: 10,             // number  - Maximum number of AI reports to generate per test run
+    // },
     // timeout : 0,                  // number - Test timeout in seconds
     // slowMo: 0,                    // number - Slow down test execution (Default: 0 seconds)
     // parallel: 0,                  // number - Number of parallel workers

package/src/hooks/hooks.js

@@ -21,6 +21,8 @@ const allure = require("allure-js-commons");
 const ffprobe = require("ffprobe-static");
 const ffmpegPath = require("ffmpeg-static");
 const { execSync } = require("child_process");
+const { attachAiBugReport } = require("artes/src/helper/controller/aiBugReporter");
+
 
 const HTTP_METHODS = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"];
 
@@ -157,11 +159,31 @@ AfterStep(async function ({ pickleStep }) {
 });
 
 After(async function ({ result, pickle }) {
+  const shouldReport =
+  cucumberConfig.default.successReport || result?.status !== Status.PASSED;
+  
+await attachResponse(allure.attachment);
+
+if (shouldReport && cucumberConfig.ai.ai) {
+  await attachAiBugReport({
+    result,
+    pickle,
+    response: context.response,
+    language: cucumberConfig.ai.language,
+    url: cucumberConfig.ai.url,
+    aiModel: cucumberConfig.ai.model,
+    aiKey: cucumberConfig.ai.key,
+    maxReports: cucumberConfig.ai.maxReports,
+    maxTokens: cucumberConfig.ai.maxTokens
+  });
+}
+
+
   if (typeof projectHooks.After === "function") {
     await projectHooks.After();
   }
 
-  await attachResponse(allure.attachment);
+
   context.response = await {};
 
   Object.keys(context.vars).length > 0 &&
@@ -171,8 +193,6 @@ After(async function ({ result, pickle }) {
       "application/json",
     );
 
-  const shouldReport =
-    cucumberConfig.default.successReport || result?.status !== Status.PASSED;
 
   if (shouldReport & (context.page.url() !== "about:blank")) {
     const screenshotBuffer = await context.page.screenshot({ type: "png" });