genat-mcp 2.2.4 → 2.2.6

package/README.md

@@ -40,6 +40,14 @@ npm install /path/to/n8n_playwright_tests/mcp-genat
 | **N8N_ANALYZE_STATES** | No       | (off)   | Set to `1`, `true`, or `yes` to analyze dropdown/combobox expanded states and include state-specific violations in generated tests. Used as default when the tool is invoked without `analyzeStates`; also used by run-genat.mjs. Increases analysis time. |
 | **GENAT_PROJECT_ROOT** | No       | (cwd)   | Base path for resolving `parentProjectFolder`. When set, `parentProjectFolder` is resolved relative to this path. Use when your project is outside the MCP's working directory. Example: if your pytest project is at `/Users/me/projects/ill_tests`, set `GENAT_PROJECT_ROOT=/Users/me/projects` and use `parentProjectFolder ill_tests` in the prompt. |
 
+## Framework detection and auto-discovery
+
+GenAT detects **language** (TypeScript, JavaScript, Python), **BDD framework** (Cucumber, pytest-bdd, Behave), and **Page Object pattern** from the project folder.
+
+**Auto-discovery:** When you pass a folder that contains both tooling (e.g. `package.json` at root) and a test subfolder (`tests/`, `e2e/`, `tests/e2e/`, `tests/accessibility/`), GenAT scores each candidate and uses the folder with the most test-specific content (`.feature` files, `conftest.py`, `*_test.py`, `.spec.ts`, `pages/`, `steps/`, etc.). This ensures correct detection when tests live in subfolders.
+
+**Path guidance:** Pass the project root (e.g. `.` or `/path/to/project`). GenAT will auto-discover the best folder when tests are in `tests/` or `e2e/`. For monorepos, pass the specific test project folder (e.g. `packages/e2e-tests`) when the root has mixed content.
+
 ## Cursor MCP config
 
 **Using npx (local install):**

package/detect-framework.js

@@ -7,21 +7,73 @@ import { join, resolve } from 'path';
 
 const ALLOWED_BDD = ['cucumber', 'pytest-bdd', 'behave', 'none'];
 
+const SKIP_DIRS = ['node_modules', '.git', '__pycache__', '.venv', 'venv', 'dist', 'build', 'coverage'];
+
+/**
+ * Score a directory for test-specific content (higher = more test content).
+ * @param {string} dir
+ * @param {(d: string, p: (f: string) => boolean) => string[]} w
+ * @returns {number}
+ */
+function scoreTestContent(dir, w) {
+  let score = 0;
+  if (existsSync(join(dir, 'pages'))) score += 2;
+  if (existsSync(join(dir, 'page_objects'))) score += 2;
+  if (existsSync(join(dir, 'steps'))) score += 2;
+  if (existsSync(join(dir, 'features'))) score += 2;
+  score += w(dir, (f) => f.endsWith('.feature')).length;
+  score += w(dir, (f) => f === 'conftest.py').length;
+  score += w(dir, (f) => f.endsWith('_test.py')).length;
+  score += w(dir, (f) => f.endsWith('.spec.ts')).length;
+  score += w(dir, (f) => f.endsWith('.spec.js')).length;
+  return score;
+}
+
+/**
+ * Auto-discover best project root when tests live in subfolders.
+ * @param {string} root - resolved path passed by user
+ * @returns {string} - root or subfolder with higher test content score
+ */
+function findBestProjectRoot(root) {
+  const candidates = [root];
+  const subdirs = ['tests', 'e2e', 'tests/e2e', 'tests/accessibility'];
+  for (const sub of subdirs) {
+    const p = join(root, sub);
+    if (existsSync(p)) candidates.push(p);
+  }
+  if (candidates.length === 1) return root;
+
+  const w = (d, pred) => walk(d, pred);
+  let best = root;
+  let bestScore = scoreTestContent(root, w);
+  for (const c of candidates) {
+    if (c === root) continue;
+    const s = scoreTestContent(c, w);
+    if (s > bestScore) {
+      bestScore = s;
+      best = c;
+    }
+  }
+  return best;
+}
+
 /**
  * @param {string} parentProjectFolder - absolute or relative path to project root
  * @returns {{ scriptType: 'typescript'|'javascript'|'python', bddFramework: string, pageObject: boolean, projectSummary: string }}
  */
 export function detectFramework(parentProjectFolder) {
-  const root = resolve(parentProjectFolder);
+  let root = resolve(parentProjectFolder);
   if (!existsSync(root) || !readdirSync(root).length) {
     return {
       scriptType: 'typescript',
       bddFramework: 'none',
       pageObject: false,
-      projectSummary: 'Folder not found or empty; using defaults.',
+      projectSummary: `Folder not found or empty; using defaults. (resolved: ${root})`,
     };
   }
 
+  root = findBestProjectRoot(root);
+
   let scriptType = 'typescript';
   let bddFramework = 'none';
   let pageObject = false;
@@ -44,8 +96,43 @@ export function detectFramework(parentProjectFolder) {
   const hasTs = hasExtension(root, '.ts') || hasExtension(root, '.spec.ts');
   const hasJs = hasExtension(root, '.js') || hasExtension(root, '.spec.js') || hasExtension(root, '.jsx') || hasExtension(root, '.spec.jsx');
   const hasPy = hasExtension(root, '.py') || hasExtension(root, '_test.py');
+  const hasConftest = walk(root, (f) => f === 'conftest.py').length > 0;
 
-  if (hasPy && (hasRequirements || hasPyproject || hasPy)) {
+  // When both package.json and pyproject.toml exist, prefer Python if pyproject indicates Python project
+  let pyprojectIndicatesPython = false;
+  let playwrightInPython = false;
+  if (hasPyproject) {
+    try {
+      const pyproject = readFileSync(join(root, 'pyproject.toml'), 'utf8');
+      pyprojectIndicatesPython = /\[project\]/.test(pyproject) && (/pytest/i.test(pyproject) || /pytest-bdd/i.test(pyproject));
+      playwrightInPython = /playwright/i.test(pyproject);
+    } catch (_) {}
+  }
+  if (hasRequirements && !playwrightInPython) {
+    try {
+      playwrightInPython = /playwright/i.test(readFileSync(join(root, 'requirements.txt'), 'utf8'));
+    } catch (_) {}
+  }
+  for (const sub of ['tests', 'e2e']) {
+    const p = join(root, sub, 'requirements.txt');
+    if (existsSync(p) && !playwrightInPython) {
+      try {
+        playwrightInPython = /playwright/i.test(readFileSync(p, 'utf8'));
+        if (playwrightInPython) break;
+      } catch (_) {}
+    }
+  }
+
+  let playwrightInNode = false;
+  if (hasPackageJson) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+      const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+      playwrightInNode = Object.keys(deps).some((k) => /@playwright\/test|^playwright$/i.test(k));
+    } catch (_) {}
+  }
+
+  if ((hasPy || hasConftest || pyprojectIndicatesPython) && (hasRequirements || hasPyproject || hasPy || hasConftest) && !(playwrightInNode && !playwrightInPython && !hasPy && !hasConftest)) {
     scriptType = 'python';
     summaryParts.push('Language: Python');
   } else if (hasPackageJson || hasTsConfig || hasTs || hasJs) {
@@ -62,57 +149,145 @@ export function detectFramework(parentProjectFolder) {
   }
 
   // BDD: Cucumber (package.json), pytest-bdd, Behave
-  if ((scriptType === 'typescript' || scriptType === 'javascript') && hasPackageJson) {
+  function hasCucumberInPackage(pkgPath) {
     try {
-      const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
       const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-      if (deps['@cucumber/cucumber'] || deps['cucumber']) {
-        bddFramework = 'cucumber';
-        summaryParts.push('BDD: Cucumber');
+      const keys = Object.keys(deps);
+      return keys.some((k) => /@cucumber\/cucumber|cucumber-js|cucumber/i.test(k));
+    } catch (_) {
+      return false;
+    }
+  }
+  if ((scriptType === 'typescript' || scriptType === 'javascript') && hasPackageJson) {
+    if (hasCucumberInPackage(join(root, 'package.json'))) {
+      bddFramework = 'cucumber';
+      summaryParts.push('BDD: Cucumber');
+    } else {
+      for (const sub of ['tests', 'e2e', 'tests/e2e']) {
+        const p = join(root, sub, 'package.json');
+        if (existsSync(p) && hasCucumberInPackage(p)) {
+          bddFramework = 'cucumber';
+          summaryParts.push('BDD: Cucumber (subfolder)');
+          break;
+        }
       }
-    } catch (_) {}
+    }
   }
   const hasFeatureFiles = hasExtension(root, '.feature');
   if (scriptType === 'python') {
     try {
-      if (hasRequirements) {
-        const req = readFileSync(join(root, 'requirements.txt'), 'utf8');
+      function readReq(path) {
+        try {
+          return readFileSync(path, 'utf8');
+        } catch (_) {
+          return '';
+        }
+      }
+      const reqPaths = [join(root, 'requirements.txt')];
+      for (const sub of ['tests', 'e2e', 'tests/e2e']) {
+        const p = join(root, sub, 'requirements.txt');
+        if (existsSync(p)) reqPaths.push(p);
+      }
+      for (const reqPath of reqPaths) {
+        if (!existsSync(reqPath)) continue;
+        const req = readReq(reqPath);
         if (/pytest-bdd/i.test(req)) {
           bddFramework = 'pytest-bdd';
           summaryParts.push('BDD: pytest-bdd');
-        } else if (/behave/i.test(req)) {
+          break;
+        }
+        if (/behave/i.test(req)) {
           bddFramework = 'behave';
           summaryParts.push('BDD: Behave');
+          break;
         }
       }
+      if (bddFramework === 'none' && hasPyproject) {
+        try {
+          const pyproject = readFileSync(join(root, 'pyproject.toml'), 'utf8');
+          if (/pytest-bdd/i.test(pyproject)) {
+            bddFramework = 'pytest-bdd';
+            summaryParts.push('BDD: pytest-bdd (pyproject.toml)');
+          } else if (/behave/i.test(pyproject)) {
+            bddFramework = 'behave';
+            summaryParts.push('BDD: Behave (pyproject.toml)');
+          }
+        } catch (_) {}
+      }
       if (bddFramework === 'none' && existsSync(join(root, 'features'))) {
-        bddFramework = 'behave';
-        summaryParts.push('BDD: Behave (features/ present)');
+        // features/ exists: check .py files for pytest_bdd before defaulting to behave
+        const pyFilePaths = walkWithPaths(root, (f) => f.endsWith('.py'));
+        let foundPytestBdd = false;
+        for (const full of pyFilePaths) {
+          try {
+            const content = readFileSync(full, 'utf8');
+            if (/pytest_bdd|pytest-bdd|from pytest_bdd|import pytest_bdd/i.test(content)) {
+              foundPytestBdd = true;
+              break;
+            }
+          } catch (_) {}
+        }
+        if (foundPytestBdd) {
+          bddFramework = 'pytest-bdd';
+          summaryParts.push('BDD: pytest-bdd (found in .py files)');
+        } else {
+          bddFramework = 'behave';
+          summaryParts.push('BDD: Behave (features/ present)');
+        }
       }
       if (bddFramework === 'none' && hasFeatureFiles) summaryParts.push('Found .feature files');
     } catch (_) {}
   }
   if ((scriptType === 'typescript' || scriptType === 'javascript') && hasFeatureFiles && bddFramework === 'none') {
-    summaryParts.push('Found .feature files (consider Cucumber)');
+    bddFramework = 'cucumber';
+    summaryParts.push('BDD: Cucumber (from .feature files)');
   }
 
-  // Page Object: pages/ or *Page.ts, *Page.js, *_page.py
+  // Page Object: pages/, page_objects/, or *Page.ts, *Page.js, *_page.py, *page.py
   try {
+    const hasPagesInSubdir = (function findPagesDir(dir) {
+      try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const e of entries) {
+          if (e.isDirectory() && (e.name === 'pages' || e.name === 'page_objects' || e.name === 'support' || e.name === 'locators')) return true;
+          if (e.isDirectory() && !SKIP_DIRS.includes(e.name)) {
+            if (findPagesDir(join(dir, e.name))) return true;
+          }
+        }
+      } catch (_) {}
+      return false;
+    })(root);
     if (existsSync(join(root, 'pages'))) {
       pageObject = true;
       summaryParts.push('Page Object: pages/ directory');
+    } else if (existsSync(join(root, 'page_objects'))) {
+      pageObject = true;
+      summaryParts.push('Page Object: page_objects/ directory');
+    } else if (existsSync(join(root, 'support'))) {
+      pageObject = true;
+      summaryParts.push('Page Object: support/ directory');
+    } else if (existsSync(join(root, 'locators'))) {
+      pageObject = true;
+      summaryParts.push('Page Object: locators/ directory');
+    } else if (hasPagesInSubdir) {
+      pageObject = true;
+      summaryParts.push('Page Object: pages/ or page_objects/ or support/ in subdir');
     } else {
-      const pageTs = walk(root, (f) => f.endsWith('Page.ts') || f.endsWith('Page.tsx'));
-      const pageJs = walk(root, (f) => f.endsWith('Page.js') || f.endsWith('Page.jsx'));
-      const pagePy = walk(root, (f) => f.endsWith('_page.py') || f.endsWith('Page.py'));
+      const pageTs = walk(root, (f) => f.endsWith('Page.ts') || f.endsWith('Page.tsx') || f.endsWith('page.ts') || f.endsWith('page.tsx'));
+      const pageJs = walk(root, (f) => f.endsWith('Page.js') || f.endsWith('Page.jsx') || f.endsWith('page.js') || f.endsWith('page.jsx'));
+      const pagePy = walk(root, (f) => f.endsWith('_page.py') || f.endsWith('Page.py') || f.endsWith('page.py'));
       if (pageTs.length || pageJs.length || pagePy.length) {
         pageObject = true;
-        summaryParts.push('Page Object: *Page.ts / *Page.js / *_page.py files');
+        summaryParts.push('Page Object: *Page.ts / *page.ts / *_page.py files');
       }
     }
   } catch (_) {}
 
-  const projectSummary = summaryParts.length ? summaryParts.join('; ') : 'No framework hints detected.';
+  const projectSummary = [
+    ...(summaryParts.length ? summaryParts : ['No framework hints detected']),
+    `(scanned: ${root})`,
+  ].join('; ');
 
   return {
     scriptType,
@@ -122,6 +297,30 @@ export function detectFramework(parentProjectFolder) {
   };
 }
 
+/**
+ * Walk directory and return full paths of files matching predicate.
+ * @param {string} dir
+ * @param {(f: string) => boolean} predicate
+ * @param {string[]} [acc]
+ * @returns {string[]}
+ */
+function walkWithPaths(dir, predicate, acc = []) {
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.includes(e.name)) {
+          walkWithPaths(full, predicate, acc);
+        }
+      } else if (predicate(e.name)) {
+        acc.push(full);
+      }
+    }
+  } catch (_) {}
+  return acc;
+}
+
 /**
  * @param {string} dir
  * @param {(f: string) => boolean} predicate
@@ -129,16 +328,18 @@ export function detectFramework(parentProjectFolder) {
  * @returns {string[]}
  */
 function walk(dir, predicate, acc = []) {
-  const entries = readdirSync(dir, { withFileTypes: true });
-  for (const e of entries) {
-    const full = join(dir, e.name);
-    if (e.isDirectory()) {
-      if (e.name !== 'node_modules' && e.name !== '.git' && e.name !== '__pycache__' && e.name !== '.venv' && e.name !== 'venv') {
-        walk(full, predicate, acc);
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.includes(e.name)) {
+          walk(full, predicate, acc);
+        }
+      } else if (predicate(e.name)) {
+        acc.push(e.name);
       }
-    } else if (predicate(e.name)) {
-      acc.push(e.name);
     }
-  }
+  } catch (_) {}
   return acc;
 }

package/index.js

@@ -52,7 +52,7 @@ function insecureHttpsFetch(url, { method = 'GET', headers = {}, body }) {
 const server = new McpServer(
   {
     name: 'GenAT',
-    version: '2.2.4',
+    version: '2.2.6',
   },
   {
     capabilities: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genat-mcp",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "mcpName": "io.github.asokans@oclc.org/genat",
   "description": "MCP server GenAT: generate accessibility tests via n8n workflow (url + project folder)",
   "type": "module",