reactjsquality-check911 1.0.0

package/commands/scan.js

@@ -0,0 +1,243 @@
+"use strict";
+
+const fs   = require("fs");
+const path = require("path");
+
+function readFile(f) { try { return fs.readFileSync(f, "utf8"); } catch (_) { return ""; } }
+
+const SRC_EXTS = /\.(js|jsx|ts|tsx|vue|svelte)$/;
+
+// ── file walkers ──────────────────────────────────────────────────────────────
+
+function walk(dir, buckets) {
+    if (!fs.existsSync(dir)) return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (/node_modules|\.git|dist|build|\.next|coverage|\.cache/.test(entry.name)) continue;
+            walk(full, buckets);
+        } else if (SRC_EXTS.test(entry.name)) {
+            classify(full, entry.name, buckets);
+        }
+    }
+}
+
+function classify(full, name, buckets) {
+    if (name.includes(".test.") || name.includes(".spec.") || full.includes("__tests__")) {
+        buckets.tests.push(full); return;
+    }
+    const src = readFile(full);
+    if (/\bplaywright\b|test\.describe|test\.it|test\(/.test(src) && !src.includes("export default")) {
+        buckets.e2e.push(full); return;
+    }
+    if (/pages\/|app\/.*page\.(js|jsx|ts|tsx)$|routes\//.test(full.replace(/\\/g, "/"))) {
+        buckets.pages.push(full); return;
+    }
+    if (/hooks\/|use[A-Z]\w+\.(js|jsx|ts|tsx)$/.test(full.replace(/\\/g, "/"))) {
+        buckets.hooks.push(full); return;
+    }
+    if (/context\/|provider\/|Context\.(js|jsx|ts|tsx)$|Provider\.(js|jsx|ts|tsx)$/.test(full.replace(/\\/g, "/"))) {
+        buckets.contexts.push(full); return;
+    }
+    if (/services\/|api\/|client\/|\.service\.(js|ts)$/.test(full.replace(/\\/g, "/"))) {
+        buckets.services.push(full); return;
+    }
+    if (/store\/|slice\/|reducer\/|\.slice\.(js|ts)$|\.store\.(js|ts)$/.test(full.replace(/\\/g, "/"))) {
+        buckets.stores.push(full); return;
+    }
+    if (/utils\/|helpers\/|lib\/|\.util\.(js|ts)$|\.helper\.(js|ts)$/.test(full.replace(/\\/g, "/"))) {
+        buckets.utils.push(full); return;
+    }
+    if (src.includes("export default") && (src.includes("return (") || src.includes("=> ("))) {
+        buckets.components.push(full); return;
+    }
+    buckets.other.push(full);
+}
+
+// ── component analysis ────────────────────────────────────────────────────────
+
+function extractComponentName(src, filePath) {
+    const m = /(?:export default function|const|function)\s+([A-Z]\w+)/.exec(src);
+    return m ? m[1] : path.basename(filePath, path.extname(filePath));
+}
+
+function extractProps(src) {
+    const m = /(?:interface|type)\s+\w*Props\s*[={]([^}]+)}/s.exec(src);
+    if (!m) return [];
+    return (m[1].match(/(\w+)\s*[?:]?\s*:/g) || []).map(p => p.replace(/[?:]/g, "").trim()).slice(0, 8);
+}
+
+function extractHookDeps(src) {
+    const deps = new Set();
+    const re = /use([A-Z]\w+)\s*\(/g;
+    let m;
+    while ((m = re.exec(src)) !== null) {
+        const hook = "use" + m[1];
+        if (!["useState", "useEffect", "useCallback", "useMemo", "useRef", "useContext", "useReducer"].includes(hook))
+            deps.add(hook);
+    }
+    return [...deps].slice(0, 5);
+}
+
+function extractApiCalls(src) {
+    const calls = [];
+    const re = /(?:fetch|axios\.(?:get|post|put|delete|patch))\s*\(\s*['"`]([^'"`]+)['"`]/g;
+    let m;
+    while ((m = re.exec(src)) !== null) calls.push(m[1]);
+    return [...new Set(calls)].slice(0, 5);
+}
+
+function extractRoutes(src, filePath) {
+    const fp = filePath.replace(/\\/g, "/");
+    const routeM = /pages\/(.+?)\.(js|jsx|ts|tsx)$/.exec(fp) || /app\/(.+?)\/page\.(js|jsx|ts|tsx)$/.exec(fp);
+    return routeM ? "/" + routeM[1].replace(/\/index$/, "").replace(/\[(\w+)\]/, ":$1") : null;
+}
+
+// ── markdown builders ─────────────────────────────────────────────────────────
+
+function buildComponentIndex(buckets) {
+    const rel = f => f.replace(/\\/g, "/");
+    let md = "# Component Index\n\n";
+
+    const sections = [
+        ["Pages / Routes",    buckets.pages],
+        ["Components",        buckets.components],
+        ["Custom Hooks",      buckets.hooks],
+        ["State / Stores",    buckets.stores],
+        ["Contexts",          buckets.contexts],
+        ["Services / API",    buckets.services],
+        ["Utilities",         buckets.utils],
+        ["Tests (Unit)",      buckets.tests],
+        ["Tests (E2E)",       buckets.e2e],
+    ];
+
+    for (const [title, files] of sections) {
+        if (!files.length) continue;
+        md += `## ${title}\n`;
+        files.forEach(f => (md += `- [${path.basename(f)}](${rel(f)})\n`));
+        md += "\n";
+    }
+    return md;
+}
+
+function buildArchitecture(buckets) {
+    let md = "# Frontend Architecture\n\n";
+
+    // Overview
+    md += "## Overview\n\n";
+    md += `| | |\n|---|---|\n`;
+    md += `| **Pages / Routes** | ${buckets.pages.length} |\n`;
+    md += `| **Components** | ${buckets.components.length} |\n`;
+    md += `| **Custom Hooks** | ${buckets.hooks.length} |\n`;
+    md += `| **State / Stores** | ${buckets.stores.length} |\n`;
+    md += `| **Services / API** | ${buckets.services.length} |\n`;
+    md += `| **Unit Tests** | ${buckets.tests.length} |\n`;
+    md += `| **E2E Tests** | ${buckets.e2e.length} |\n\n`;
+
+    // Pages
+    if (buckets.pages.length) {
+        md += "---\n\n## Pages / Routes\n\n";
+        for (const f of buckets.pages) {
+            const src   = readFile(f);
+            const name  = extractComponentName(src, f);
+            const route = extractRoutes(src, f);
+            const apis  = extractApiCalls(src);
+            md += `### ${name}\n\n`;
+            if (route) md += `**Route**: \`${route}\`  \n`;
+            md += `**File**: \`${f.replace(/\\/g, "/")}\`  \n`;
+            if (apis.length) md += `**API calls**: ${apis.map(a => `\`${a}\``).join(", ")}  \n`;
+            md += "\n";
+        }
+    }
+
+    // Components
+    if (buckets.components.length) {
+        md += "---\n\n## Components\n\n";
+        for (const f of buckets.components) {
+            const src   = readFile(f);
+            const name  = extractComponentName(src, f);
+            const props = extractProps(src);
+            const hooks = extractHookDeps(src);
+            const apis  = extractApiCalls(src);
+
+            md += `### ${name}\n\n`;
+            md += `**File**: \`${f.replace(/\\/g, "/")}\`  \n`;
+            if (props.length) md += `**Props**: ${props.map(p => `\`${p}\``).join(", ")}  \n`;
+            if (hooks.length) md += `**Uses hooks**: ${hooks.join(", ")}  \n`;
+            if (apis.length)  md += `**Fetches**: ${apis.map(a => `\`${a}\``).join(", ")}  \n`;
+            md += "\n";
+        }
+    }
+
+    // Custom Hooks
+    if (buckets.hooks.length) {
+        md += "---\n\n## Custom Hooks\n\n";
+        for (const f of buckets.hooks) {
+            const src  = readFile(f);
+            const name = path.basename(f, path.extname(f));
+            const apis = extractApiCalls(src);
+            md += `### ${name}\n\n`;
+            md += `**File**: \`${f.replace(/\\/g, "/")}\`  \n`;
+            if (apis.length) md += `**API calls**: ${apis.map(a => `\`${a}\``).join(", ")}  \n`;
+            md += "\n";
+        }
+    }
+
+    // Services
+    if (buckets.services.length) {
+        md += "---\n\n## Services / API Layer\n\n";
+        for (const f of buckets.services) {
+            const src  = readFile(f);
+            const name = path.basename(f, path.extname(f));
+            const apis = extractApiCalls(src);
+            const fns  = [...(src.matchAll(/export (?:async )?function (\w+)|export const (\w+)\s*=/g) || [])]
+                         .map(m => m[1] || m[2]).filter(Boolean).slice(0, 8);
+            md += `### ${name}\n\n`;
+            md += `**File**: \`${f.replace(/\\/g, "/")}\`  \n`;
+            if (fns.length)  md += `**Exports**: ${fns.map(n => `\`${n}()\``).join(", ")}  \n`;
+            if (apis.length) md += `**Endpoints**: ${apis.map(a => `\`${a}\``).join(", ")}  \n`;
+            md += "\n";
+        }
+    }
+
+    // Stores
+    if (buckets.stores.length) {
+        md += "---\n\n## State / Stores\n\n";
+        for (const f of buckets.stores) {
+            const name = path.basename(f, path.extname(f));
+            md += `### ${name}\n\n`;
+            md += `**File**: \`${f.replace(/\\/g, "/")}\`  \n\n`;
+        }
+    }
+
+    // Layer diagram
+    md += "---\n\n## Application Layers\n\n```\n";
+    md += "Browser / User\n    │\n    ▼\n";
+    if (buckets.pages.length)    md += "Pages / Routes        ← Next.js routing or React Router\n    │\n    ▼\n";
+    if (buckets.components.length) md += "Components            ← UI building blocks\n    │\n    ▼\n";
+    if (buckets.hooks.length)    md += "Custom Hooks          ← shared stateful logic\n    │\n    ▼\n";
+    if (buckets.stores.length)   md += "State / Stores        ← global state (Redux / Zustand / Pinia)\n    │\n    ▼\n";
+    if (buckets.services.length) md += "Services / API Layer  ← HTTP calls to backend\n    │\n    ▼\n";
+    md += "Backend API\n```\n";
+
+    return md;
+}
+
+module.exports = function scan() {
+    const buckets = {
+        pages: [], components: [], hooks: [], contexts: [],
+        stores: [], services: [], utils: [], tests: [], e2e: [], other: []
+    };
+
+    console.log("Scanning repository...");
+    const srcDirs = ["src", "app", "pages", "components", "hooks", "services", "stores", "lib"];
+    for (const dir of srcDirs) walk(dir, buckets);
+
+    fs.mkdirSync("docs", { recursive: true });
+
+    fs.writeFileSync("docs/component-index.md", buildComponentIndex(buckets));
+    console.log("docs/component-index.md updated");
+
+    fs.writeFileSync("docs/architecture.md", buildArchitecture(buckets));
+    console.log("docs/architecture.md updated");
+};

package/mcp-server/requirements.txt

@@ -0,0 +1 @@
+fastmcp

package/mcp-server/server.py

@@ -0,0 +1,61 @@
+import os
+from fastmcp import FastMCP
+from tools.code_fixer import code_fixer
+from tools.test_generator import test_generator
+from tools.component_scanner import component_scanner
+from tools.playwright_helper import playwright_helper
+
+mcp = FastMCP("ReactJS Quality Agent")
+
+@mcp.tool()
+def ping():
+    return "MCP Working"
+
+@mcp.tool()
+def fix():
+    """
+    Get everything needed to fix staged files in one pass:
+    file contents + ESLint violations + fix instructions.
+    Call this when the user asks to fix quality issues in staged files.
+    """
+    return code_fixer()
+
+@mcp.tool()
+def generate_tests():
+    """
+    Generate Jest tests for staged or recently changed source files.
+    Call this when the user asks to generate tests, add test coverage,
+    or write unit tests.
+    """
+    return test_generator()
+
+@mcp.tool()
+def scan():
+    """
+    Scan the project and return a structured index of components, pages,
+    hooks, services, and stores. Use this first to navigate the codebase.
+    """
+    return component_scanner()
+
+@mcp.tool()
+def playwright_setup():
+    """
+    Return Playwright test generation instructions and existing test patterns
+    for the current project. Use this when the user asks to generate
+    Playwright / E2E tests for a page or user flow.
+    """
+    return playwright_helper()
+
+@mcp.tool()
+def read_file(path: str) -> str:
+    """
+    Read a specific source file by path.
+    Use scan() first to find the path, then call this.
+    """
+    if not os.path.exists(path):
+        return f"File not found: {path}"
+    with open(path, encoding="utf-8") as f:
+        return f.read()
+
+if __name__ == "__main__":
+    mcp.run()

package/mcp-server/tools/code_fixer.py

@@ -0,0 +1,130 @@
+import json
+import os
+import re
+import subprocess
+from pathlib import Path
+
+SRC_EXTS = (".js", ".jsx", ".ts", ".tsx", ".vue", ".svelte")
+
+
+def get_staged_files():
+    r = subprocess.run(["git", "diff", "--cached", "--name-only"],
+                       capture_output=True, text=True)
+    return [f.strip() for f in r.stdout.splitlines()
+            if f.strip().endswith(SRC_EXTS) and os.path.exists(f.strip())]
+
+
+def get_changed_line_ranges() -> dict:
+    r = subprocess.run(["git", "diff", "--cached", "--unified=0"],
+                       capture_output=True, text=True)
+    ranges: dict = {}
+    cur = None
+    for line in r.stdout.splitlines():
+        fm = re.match(r'^\+\+\+ b/(.+)$', line)
+        if fm:
+            cur = fm.group(1)
+            ranges.setdefault(cur, [])
+            continue
+        if line.startswith("+++ /dev/null"):
+            cur = None
+            continue
+        hm = re.match(r'^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@', line)
+        if hm and cur:
+            start = int(hm.group(1))
+            count = int(hm.group(2)) if hm.group(2) is not None else 1
+            if count > 0:
+                ranges[cur].append([start, start + count - 1])
+    return ranges
+
+
+def _find_ranges(abs_path: str, changed_ranges: dict):
+    norm = abs_path.replace("\\", "/").lower()
+    for git_path, ranges in changed_ranges.items():
+        gn = git_path.lower()
+        if norm == gn or norm.endswith("/" + gn):
+            return ranges
+    return None
+
+
+def _in_range(line_num: int, ranges) -> bool:
+    if not ranges:
+        return False
+    return any(s <= line_num <= e for s, e in ranges)
+
+
+def run_eslint(files: list) -> list:
+    """Run ESLint with JSON reporter and return raw results."""
+    try:
+        result = subprocess.run(
+            ["npx", "eslint"] + files + ["--format", "json"],
+            capture_output=True, text=True
+        )
+        return json.loads(result.stdout or "[]")
+    except Exception:
+        return []
+
+
+def code_fixer() -> str:
+    staged = get_staged_files()
+    if not staged:
+        return "No staged JS/TS files found. Run `git add <files>` first."
+
+    changed_ranges = get_changed_line_ranges()
+
+    # Run ESLint
+    eslint_results = run_eslint(staged)
+
+    # Filter to changed chunks only
+    violations = []
+    for file_result in eslint_results:
+        fpath     = file_result.get("filePath", "")
+        ranges    = _find_ranges(fpath, changed_ranges)
+        if ranges is None:
+            continue
+        fname = os.path.basename(fpath)
+        for msg in file_result.get("messages", []):
+            if not _in_range(msg.get("line", 0), ranges):
+                continue
+            severity = "error" if msg.get("severity") == 2 else "warning"
+            rule     = msg.get("ruleId") or "unknown"
+            line     = msg.get("line", "?")
+            text     = msg.get("message", "")
+            violations.append(f"  [ESLint:{rule}] {fname}:{line} — {text} ({severity})")
+
+    if not violations:
+        return "No ESLint violations in your changed lines — nothing to fix."
+
+    # Read changed chunks only
+    chunks_text = ""
+    for f in staged:
+        git_path    = f.replace("\\", "/")
+        file_ranges = changed_ranges.get(git_path) or next(
+            (rng for gp, rng in changed_ranges.items()
+             if gp.lower().endswith("/" + git_path.lower().split("/")[-1])),
+            None
+        )
+        lines  = Path(f).read_text(encoding="utf-8").splitlines()
+        chunks = []
+        if file_ranges:
+            for start, end in file_ranges:
+                chunk_lines = lines[start - 1: end]
+                chunks.append(f"Lines {start}–{end}:\n" + "\n".join(chunk_lines))
+        chunks_text += f"\n### {f}\n" + "\n\n".join(chunks) + "\n"
+
+    violations_text = "\n".join(violations)
+
+    return f"""You are a Senior React/TypeScript Engineer. Fix ONLY the ESLint violations listed below.
+They are all within the changed chunks of the current commit — do not touch any other lines.
+
+## Changed Chunks
+{chunks_text}
+
+## ESLint Violations in Changed Lines
+{violations_text}
+
+## Instructions
+1. Fix every ESLint error (unused variables, missing return types, console.log, any types)
+2. Fix every TypeScript violation (implicit any, missing types, strict mode issues)
+3. Change ONLY the lines reported above — do not reformat or refactor anything else
+4. Return the corrected chunks showing the fixed lines with their line numbers
+"""

package/mcp-server/tools/component_scanner.py

@@ -0,0 +1,47 @@
+import os
+import re
+from pathlib import Path
+
+SRC_EXTS  = (".js", ".jsx", ".ts", ".tsx", ".vue", ".svelte")
+SKIP_DIRS = {"node_modules", ".git", "dist", "build", ".next", "coverage", ".cache"}
+
+
+def walk(root):
+    files = []
+    if not os.path.exists(root):
+        return files
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]
+        for fname in filenames:
+            if fname.endswith(SRC_EXTS):
+                files.append(os.path.join(dirpath, fname))
+    return files
+
+
+def component_scanner() -> str:
+    src_dirs = ["src", "app", "pages", "components", "hooks", "services", "stores", "lib"]
+    all_files = []
+    for d in src_dirs:
+        all_files.extend(walk(d))
+
+    if not all_files:
+        return "No source files found. Run from the project root."
+
+    summary = []
+    for f in all_files[:60]:  # cap to avoid huge responses
+        fp   = f.replace("\\", "/")
+        name = os.path.basename(f)
+        try:
+            src = Path(f).read_text(encoding="utf-8")
+        except Exception:
+            continue
+        exports = re.findall(r'export\s+(?:default\s+)?(?:async\s+)?(?:function|const|class)\s+(\w+)', src)
+        api_calls = re.findall(r'(?:fetch|axios\.(?:get|post|put|delete|patch))\s*\(\s*[\'"`]([^\'"`]+)[\'"`]', src)
+        line = f"- {fp}"
+        if exports:
+            line += f" — exports: {', '.join(exports[:4])}"
+        if api_calls:
+            line += f" — calls: {', '.join(api_calls[:3])}"
+        summary.append(line)
+
+    return "## Project File Index\n\n" + "\n".join(summary)

package/mcp-server/tools/playwright_helper.py

@@ -0,0 +1,78 @@
+import os
+import re
+import subprocess
+from pathlib import Path
+
+
+def get_staged_files():
+    r = subprocess.run(["git", "diff", "--cached", "--name-only"],
+                       capture_output=True, text=True)
+    return [f.strip() for f in r.stdout.splitlines()
+            if f.strip().endswith((".js", ".jsx", ".ts", ".tsx"))
+            and os.path.exists(f.strip())]
+
+
+def find_existing_tests():
+    tests = []
+    for root, dirs, files in os.walk("."):
+        dirs[:] = [d for d in dirs if d not in {"node_modules", ".git", "dist", ".next"}]
+        for f in files:
+            if f.endswith(".spec.ts") or f.endswith(".spec.js"):
+                tests.append(os.path.join(root, f).replace("\\", "/"))
+    return tests[:5]
+
+
+def playwright_helper() -> str:
+    staged   = get_staged_files()
+    existing = find_existing_tests()
+
+    pages = [f for f in staged if "page" in f.lower() or "pages/" in f.replace("\\", "/")]
+
+    existing_sample = ""
+    if existing:
+        try:
+            sample = Path(existing[0]).read_text(encoding="utf-8")[:1000]
+            existing_sample = f"\n## Existing Test Pattern (from {existing[0]})\n```ts\n{sample}\n```\n"
+        except Exception:
+            pass
+
+    targets = pages or staged
+    target_list = "\n".join(f"- {f}" for f in targets)
+
+    return f"""Generate Playwright E2E tests for the following pages/components.
+
+## Files to Test
+{target_list}
+{existing_sample}
+## Instructions
+- Use TypeScript + `@playwright/test`
+- File naming: `tests/{{page-name}}.spec.ts`
+- Use the Page Object Model pattern — create a class per page
+- Cover:
+  1. Happy path — the main user flow works end to end
+  2. Form validation — required fields, error messages shown correctly
+  3. Navigation — correct URL after actions
+  4. Error states — API failure, empty state, 404
+- Assertions: `expect(locator).toBeVisible()`, `.toHaveText()`, `.toHaveURL()`
+- Use `page.getByRole()`, `page.getByLabel()`, `page.getByTestId()` — not CSS selectors
+- Run with: `npx playwright test`
+
+## Example Page Object Pattern
+```ts
+import {{ Page, expect }} from '@playwright/test';
+
+export class LoginPage {{
+  constructor(private page: Page) {{}}
+
+  async goto() {{ await this.page.goto('/login'); }}
+  async login(email: string, password: string) {{
+    await this.page.getByLabel('Email').fill(email);
+    await this.page.getByLabel('Password').fill(password);
+    await this.page.getByRole('button', {{ name: 'Sign in' }}).click();
+  }}
+  async expectError(message: string) {{
+    await expect(this.page.getByRole('alert')).toHaveText(message);
+  }}
+}}
+```
+"""

package/mcp-server/tools/test_generator.py

@@ -0,0 +1,119 @@
+import os
+import re
+import subprocess
+from pathlib import Path
+
+SRC_EXTS = (".js", ".jsx", ".ts", ".tsx", ".vue")
+
+
+def get_staged_files():
+    r = subprocess.run(["git", "diff", "--cached", "--name-only"],
+                       capture_output=True, text=True)
+    return [
+        f.strip() for f in r.stdout.splitlines()
+        if f.strip().endswith(SRC_EXTS)
+        and not any(x in f for x in (".test.", ".spec.", "__tests__"))
+        and os.path.exists(f.strip())
+    ]
+
+
+def infer_framework(src: str) -> str:
+    if "from 'react'" in src or 'from "react"' in src:
+        return "react"
+    if "from 'vue'" in src or 'from "vue"' in src:
+        return "vue"
+    if "@angular/core" in src:
+        return "angular"
+    return "vanilla"
+
+
+def extract_exports(src: str) -> list:
+    exports = []
+    for m in re.finditer(r'export\s+(?:default\s+)?(?:async\s+)?(?:function|const|class)\s+(\w+)', src):
+        exports.append(m.group(1))
+    return list(dict.fromkeys(exports))  # deduplicate preserving order
+
+
+def extract_props(src: str) -> list:
+    m = re.search(r'(?:interface|type)\s+\w*Props\s*[={]([^}]+)}', src, re.DOTALL)
+    if not m:
+        return []
+    return re.findall(r'(\w+)\s*[?:]', m.group(1))[:6]
+
+
+def test_generator() -> str:
+    staged = get_staged_files()
+    if not staged:
+        return "No staged source files found. Stage your files with `git add` first."
+
+    output_parts = []
+
+    for f in staged:
+        src       = Path(f).read_text(encoding="utf-8")
+        framework = infer_framework(src)
+        exports   = extract_exports(src)
+        props     = extract_props(src)
+        fname     = os.path.basename(f)
+        name      = fname.rsplit(".", 1)[0]
+        test_file = f.rsplit(".", 1)[0] + ".test." + ("tsx" if f.endswith(".tsx") else "ts" if f.endswith(".ts") else "jsx" if f.endswith(".jsx") else "js")
+
+        if framework == "react":
+            prompt = f"""Generate Jest + React Testing Library tests for `{fname}`.
+
+File: {f}
+Exports: {', '.join(exports) if exports else name}
+Props: {', '.join(props) if props else 'none detected'}
+
+## Source
+```tsx
+{src[:3000]}
+```
+
+## Instructions
+- Test file: `{test_file}`
+- Import from: `@testing-library/react` + `@testing-library/user-event`
+- Cover: renders correctly, prop variations, user interactions, error/loading states
+- Method naming: `should {{expected}} when {{condition}}`
+- Mock fetch/axios calls with `jest.fn()`
+- Use `screen.getByRole`, `getByText`, `getByTestId` — no class/id selectors
+- Run with: `npx jest {test_file} --coverage`
+"""
+        elif framework == "vue":
+            prompt = f"""Generate Jest + Vue Test Utils tests for `{fname}`.
+
+File: {f}
+Exports: {', '.join(exports) if exports else name}
+
+## Source
+```vue
+{src[:3000]}
+```
+
+## Instructions
+- Test file: `{test_file}`
+- Import from: `@vue/test-utils`
+- Use `mount` for full rendering, `shallowMount` for unit isolation
+- Cover: props, emits, slots, computed values, user interactions
+- Mock Pinia stores with `createTestingPinia()`
+"""
+        else:
+            prompt = f"""Generate Jest tests for `{fname}`.
+
+File: {f}
+Exports: {', '.join(exports) if exports else name}
+
+## Source
+```ts
+{src[:3000]}
+```
+
+## Instructions
+- Test file: `{test_file}`
+- Cover: all exported functions — happy path, edge cases, exceptions
+- Mock dependencies with `jest.fn()` and `jest.spyOn()`
+- Method naming: `should {{expected}} when {{condition}}`
+"""
+
+        output_parts.append(prompt)
+
+    return "\n\n---\n\n".join(output_parts)