artes 1.6.3 → 1.7.0

package/README.md

@@ -4,7 +4,36 @@
 
 <h1 align="center">Artes</h1>
 
-## 🚀 Summary
+<p >
+  <a href="https://www.npmjs.com/package/artes">
+    <img src="https://img.shields.io/npm/dm/artes?label=npm&logo=npm&color=blue" alt="npm version">
+  </a>
+
+   <a href="https://github.com/4gayev1/Artes">
+    <img src="https://img.shields.io/badge/GitHub-Artes-181717?logo=github&logoColor=white" alt="GitHub Artes">
+  </a>
+
+  <a href="https://hub.docker.com/r/vahidaghayev/artes">
+    <img src="https://img.shields.io/badge/Docker-Artes-blue?logo=docker&logoColor=white" alt="Docker Artes">
+  </a>
+
+   <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript">
+    <img src="https://img.shields.io/badge/JavaScript-F7DF1E?logo=javascript&logoColor=black" alt="JavaScript">
+  </a>
+  
+  <a href="https://playwright.dev/">
+    <img src="https://img.shields.io/badge/Playwright-2EAD33?logo=playwright&logoColor=white" alt="Playwright">
+  </a>
+  
+  <a href="https://cucumber.io/">
+    <img src="https://img.shields.io/badge/Cucumber-23D96C?logo=cucumber&logoColor=white" alt="Cucumber">
+  </a>
+
+  <a href="https://www.apache.org/licenses/LICENSE-2.0">
+    <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="Apache 2.0 License">
+  </a>
+
+</p>
 
 Artes is a test runner for Playwright that executes [predefined Cucumber tests](./docs/stepDefinitions.md) and can generate Allure reports for test results. It simplifies setting up Playwright with Cucumber in your automation workflow. With Artes, you can easily run tests without writing step definitions, generate reports, and customize your testing environment.
 
@@ -20,7 +49,7 @@ Artes is a test runner for Playwright that executes [predefined Cucumber tests](
 - Well-structured, easy-to-follow documentation for a smooth learning curve
 - Designed for long-term maintainability and scalability
 
-### 🧩 Powerful & Developer-Friendly Architecture
+### 🧩 Powerful & QA-Friendly Architecture
 
 - Intuitive API for writing custom step definitions
 - Rich set of ready-to-use step definitions to speed up test creation
@@ -58,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))
@@ -115,12 +154,12 @@ npx artes [options]
 | `-rwt, --reportWithTrace` | Add trace to the report                                                            | `artes -rwt` or `artes --reportWithTrace`                             |
 | `--singleFileReport`      | Generate single file allure report                                                 | `artes -r --singleFileReport`                                         |
 | `--zip`                   | Zip the report folder after generation                                             | `artes -r --zip`                                                      |
-| `--uploadReport`          | Upload the generated report to Artes Reporting System                              | `artes --uploadReport --reporterURL "https://example.com"`            |
-| `--reporterURL`           | URL of the Artes Reporting System to upload the report                             | `artes --uploadReport --reporterURL "https://example.com"`            |
-| `--projectName`           | Name of the project in the Artes Reporting System (default: `"Artes Report"`)     | `artes --uploadReport --reporterURL "https://example.com" --projectName "My Project"` |
-| `--projectType`           | Type of the project for reporting purposes (default: `"Artes"`)                   | `artes --uploadReport --reporterURL "https://example.com" --projectType "API"` |
-| `--reportPath`            | Path to the report zip file to upload (default: `./report.zip`)                   | `artes --uploadReport --reporterURL "https://example.com" --reportPath "./my_report.zip"` |
-| 🖼️ `--logo`               | Set a custom logo in the report sidebar. Accepts an absolute path, a relative path, or a direct image URL | `artes --logo /abs/path/logo.png`<br>`artes --logo logo.png`<br>`artes --logo 'https://example.com/logo.png'` |
+| `--uploadReport`          | Upload the generated report to Artes Reporting System                              | `artes -r --zip --uploadReport --reporterURL "https://example.com"`            |
+| `--reporterURL`           | URL of the Artes Reporting System to upload the report                             | `artes -r --zip --uploadReport --reporterURL "https://example.com"`            |
+| `--projectName`           | Name of the project in the Artes Reporting System (default: `"Artes Report"`)     | `artes -r --zip --uploadReport --reporterURL "https://example.com" --projectName "My Project"` |
+| `--projectType`           | Type of the project for reporting purposes (default: `"Artes"`)                   | `artes -r --zip --uploadReport --reporterURL "https://example.com" --projectType "API"` |
+| `--reportPath`            | Path to the report zip file to upload (default: `./report.zip`)                   | `artes -r --zip --uploadReport --reporterURL "https://example.com" --reportPath "./my_report.zip"` |
+| 🖼️ `--logo`               | Set a custom logo in the report sidebar. Accepts an absolute path, a relative path, or a direct image URL | `artes -r --logo /abs/path/logo.png`<br>`artes --logo logo.png`<br>`artes --logo 'https://example.com/logo.png'` |
 | 🏢 `--brandName`          | Set the brand name displayed next to the logo in the report sidebar                | `artes --brandName 'My Company'`                                      |
 | 📄 `--reportName`         | Report name displayed on the summary widget and in the Artes Reporting System                       | `artes --reportName 'Alma UI'`  
 | 📁 `--features`           | Specify one or more feature files' relative paths to run (comma-separated)         | `artes --features "tests/features/Alma,tests/features/Banan.feature"` |
@@ -144,6 +183,18 @@ 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"` |
+| 📋 `--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
@@ -176,8 +227,8 @@ After running the `-c` flag to create a new project, the structure will look lik
       (Your feature files here)
     /POMs    // Optional
       (POM JSON file here)
-    /steps  // For custom steps
-        (Your step definition JS files here)
+    /steps  // For custom steps and hooks
+        (Your step definition and hooks JS files here)
   artes.config.js
   /report
     (Generated Allure report HTML here)
@@ -537,6 +588,19 @@ 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.maxReports`      | `10`              | Maximum number of AI reports to generate per test run.                                               |
+
+---
+
 ## 🌍 Environment Configuration
 
 | **Option** | **Default Value** | **Description**                                                                                              |

package/cucumber.config.js

@@ -191,6 +191,22 @@ 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",
+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,13 @@ 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"),
+  maxReports: args.includes("--maxReports"),
   features: args.includes("--features"),
   stepDef: args.includes("--stepDef"),
   tags: args.includes("--tags"),
@@ -87,6 +94,12 @@ 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 maxReports = getArgValue("--maxReports");
 const featureFiles = getArgValue("--features");
 const features = flags.features && featureFiles;
 const stepDef = getArgValue("--stepDef");
@@ -145,6 +158,13 @@ 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.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 +206,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);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.6.3",
+  "version": "1.7.0",
   "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 }) {
+  const { provider, modelId } = resolveProvider(aiFlag);
+
+  console.log(`Using ${provider.name} — model: ${modelId}`);
+
+  const url  = provider.buildUrl(modelId, apiKey);
+  const body = provider.buildBody(prompt, modelId);
+
+  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 }) {
+  console.log(`Using AI — endpoint: ${url}`);
+
+  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 });
+}
+
+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 });
+}
+
+
+
+
+let _reportCount = 0;
+
+
+
+const DEFAULT_DELAY_MS = 1000;
+
+async function attachAiBugReport({
+  result,
+  pickle,
+  response,
+  language = "English",
+  aiModel,
+  aiKey,
+  url,
+  maxReports = 10,
+  delayMs = DEFAULT_DELAY_MS,  
+}) {
+  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,
+      });
+      attachmentLabel = "Test Summary";
+    } else {
+      const resultCtx = buildResultContext(result);
+      reportText = await generateFailedBugReport({
+        resultCtx,
+        pickleCtx,
+        response,
+        language,
+        aiFlag: aiModel,
+        apiKey: aiKey,
+        url,   
+      });
+      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,169 @@
+
+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) => ({
+      contents        : [{ parts: [{ text: prompt }] }],
+      generationConfig: { temperature: 0.6, maxOutputTokens: 4000 },
+    }),
+    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) => ({
+      model      : modelId,
+      max_tokens : 4000,
+      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) => ({
+      model     : modelId,
+      max_tokens: 4000,
+      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) => ({
+      model      : modelId,
+      max_tokens : 4000,
+      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) => ({
+      model      : modelId,
+      max_tokens : 4000,
+      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) => ({
+      model   : modelId,
+      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) => ({
+      model      : modelId,
+      max_tokens : 4000,
+      temperature: 0.6,
+      messages   : [{ role: "user", content: prompt }],
+    }),
+    parseResp : (data) => data?.choices?.[0]?.message?.content ?? "",
+  },
+];
+
+module.exports = { PROVIDERS };

package/src/helper/controller/findDuplicateTestNames.js

@@ -60,6 +60,7 @@ function findDuplicateTestNames() {
       console.log("");
     });
     console.log("\x1b[0m");
+    console.log("");
   }
 
   return duplicates;

package/src/helper/controller/pomCollector.js

@@ -77,6 +77,7 @@ function logPomWarnings() {
   });
 
   console.log("\x1b[0m");
+  console.log("");
 }
 
 module.exports = { pomCollector, logPomWarnings };

package/src/helper/controller/testCoverageCalculator.js

@@ -73,6 +73,7 @@ function testCoverageCalculator({ silent = false } = {}) {
       console.warn(`- "${t.scenario}" ran ${t.count} times`);
     });
     console.log("\x1b[0m");
+    console.log("");
   }
 
   return {

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,37 @@ 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"
+
+            📋 --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,14 @@ 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: "gpt-4o",            // 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")
+    //   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"];
 
@@ -161,7 +163,26 @@ After(async function ({ result, pickle }) {
     await projectHooks.After();
   }
 
+  
+  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
+    });
+  }
+
+
   context.response = await {};
 
   Object.keys(context.vars).length > 0 &&
@@ -171,8 +192,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" });