reactjsquality-check911 1.0.0

package/bin/reactjsquality-check911.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+
+const { program } = require("commander");
+
+program
+    .name("reactjsquality-check911")
+    .description("React/JS quality agent — ESLint, Jest coverage, Playwright on every commit")
+    .version(require("../package.json").version);
+
+program
+    .command("init")
+    .description("Choose framework and quality checks, configure Copilot and MCP")
+    .action(() => require("../commands/init")());
+
+program
+    .command("quality")
+    .description("Run ESLint and TypeScript check on staged files (changed chunks only)")
+    .action(() => require("../commands/quality")());
+
+program
+    .command("coverage")
+    .description("Run Jest coverage on staged/changed files (80% threshold per file)")
+    .action(() => require("../commands/coverage")());
+
+program
+    .command("playwright")
+    .description("Run Playwright smoke tests against the current build")
+    .action(() => require("../commands/playwright")());
+
+program
+    .command("scan")
+    .description("Scan components, pages, and services — rebuild architecture.md")
+    .action(() => require("../commands/scan")());
+
+program
+    .command("hooks")
+    .description("Install pre-commit (ESLint + coverage) and pre-push (Playwright) git hooks")
+    .action(() => require("../commands/hooks")());
+
+program.parse(process.argv);

package/commands/coverage.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const { execSync } = require("child_process");
+const fs   = require("fs");
+const path = require("path");
+
+const THRESHOLD   = 80;
+const CONFIG_FILE = ".reactjs-quality-agent.json";
+
+function loadConfig() {
+    try { return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")); } catch (_) { return null; }
+}
+
+function getStagedSourceFiles() {
+    try {
+        const out = execSync("git diff --cached --name-only", { encoding: "utf8" });
+        return out.split("\n").map(f => f.trim()).filter(f =>
+            f &&
+            /\.(js|jsx|ts|tsx|vue)$/.test(f) &&
+            !f.includes(".test.") && !f.includes(".spec.") &&
+            !f.includes("__tests__") &&
+            fs.existsSync(f)
+        );
+    } catch (_) { return []; }
+}
+
+function findTestFile(srcFile) {
+    const base = srcFile.replace(/\.(js|jsx|ts|tsx|vue)$/, "");
+    const ext  = srcFile.match(/\.(js|jsx|ts|tsx|vue)$/)[1];
+    const testExt = ext === "js" ? "js" : ext === "jsx" ? "tsx" : "tsx";
+    return [
+        `${base}.test.${testExt}`,
+        `${base}.test.${ext}`,
+        `${base}.spec.${testExt}`,
+        `${base}.spec.${ext}`,
+        base.replace(/\/src\//, "/src/__tests__/") + `.test.${testExt}`,
+        base.replace(/\/src\//, "/src/__tests__/") + `.test.${ext}`,
+    ].find(f => fs.existsSync(f));
+}
+
+module.exports = function coverage() {
+    const config = loadConfig();
+    if (!config) {
+        console.error("No .reactjs-quality-agent.json found — run `reactjsquality-check911 init` first.");
+        process.exit(1);
+    }
+    if (!config.checks.coverage) {
+        console.log("Coverage check is disabled — skipping.");
+        return;
+    }
+
+    const sources = getStagedSourceFiles();
+    if (!sources.length) {
+        console.log("No staged source files — skipping coverage.");
+        return;
+    }
+
+    console.log(`Verifying Jest coverage for: ${sources.map(f => path.basename(f)).join(", ")}\n`);
+    const results = [];
+    let failed    = false;
+
+    for (const file of sources) {
+        const testFile = findTestFile(file);
+        if (!testFile) {
+            const expected = path.basename(file).replace(/\.(js|jsx|ts|tsx)$/, ".test.$1");
+            console.log(`  ⚠️  ${path.basename(file)} — no test file found (expected ${expected})`);
+            results.push(`⚠️  ${path.basename(file)}: no test file`);
+            continue;
+        }
+
+        try {
+            execSync(
+                `npx jest "${testFile}" --coverage --coverageReporters=json-summary --passWithNoTests --silent`,
+                { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+            );
+
+            const summaryPath = "coverage/coverage-summary.json";
+            if (!fs.existsSync(summaryPath)) {
+                results.push(`⚠️  ${path.basename(file)}: coverage-summary.json not generated`);
+                continue;
+            }
+
+            const summary  = JSON.parse(fs.readFileSync(summaryPath, "utf8"));
+            const absFile  = path.resolve(file).replace(/\\/g, "/");
+            const matched  = Object.entries(summary).find(([k]) =>
+                k.replace(/\\/g, "/") === absFile ||
+                k.replace(/\\/g, "/").endsWith("/" + file.replace(/\\/g, "/"))
+            );
+
+            if (!matched) {
+                results.push(`⚠️  ${path.basename(file)}: not found in coverage report`);
+                continue;
+            }
+
+            const pct  = matched[1].lines.pct;
+            const icon = pct >= THRESHOLD ? "✅" : "❌";
+            console.log(`  ${icon} ${path.basename(file)}: ${pct}% line coverage`);
+            results.push(`${icon} ${path.basename(file)}: ${pct}%`);
+            if (pct < THRESHOLD) failed = true;
+
+        } catch (e) {
+            console.log(`  ❌ ${path.basename(file)}: Jest failed`);
+            results.push(`❌ ${path.basename(file)}: Jest execution failed`);
+            failed = true;
+        }
+    }
+
+    console.log("\n--- Coverage Summary ---");
+    results.forEach(r => console.log(" ", r));
+
+    if (failed) {
+        console.log(`\nCoverage below ${THRESHOLD}% — add tests and try again.`);
+        process.exit(1);
+    }
+
+    console.log(`\n✅ All changed files meet the ${THRESHOLD}% coverage threshold.`);
+};

package/commands/hooks.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const { execSync } = require("child_process");
+const fs   = require("fs");
+const path = require("path");
+
+const PRE_COMMIT = `#!/bin/sh
+# reactjsquality-check911 — pre-commit hook
+# Runs ESLint and Jest coverage on staged files (changed chunks only)
+
+set -e
+
+if ! command -v reactjsquality-check911 >/dev/null 2>&1; then
+  echo "reactjsquality-check911 not found — run: npm install -g reactjsquality-check911"
+  exit 0
+fi
+
+CONFIG=".reactjs-quality-agent.json"
+if [ ! -f "$CONFIG" ]; then
+  echo "No $CONFIG found — run: reactjsquality-check911 init"
+  exit 0
+fi
+
+reactjsquality-check911 quality
+reactjsquality-check911 coverage
+`;
+
+const PRE_PUSH = `#!/bin/sh
+# reactjsquality-check911 — pre-push hook
+# Runs Playwright smoke tests before every push
+
+set -e
+
+if ! command -v reactjsquality-check911 >/dev/null 2>&1; then
+  echo "reactjsquality-check911 not found — run: npm install -g reactjsquality-check911"
+  exit 0
+fi
+
+CONFIG=".reactjs-quality-agent.json"
+if [ ! -f "$CONFIG" ]; then
+  echo "No $CONFIG found — run: reactjsquality-check911 init"
+  exit 0
+fi
+
+reactjsquality-check911 playwright
+`;
+
+module.exports = function hooks() {
+    fs.mkdirSync(".githooks", { recursive: true });
+
+    fs.writeFileSync(".githooks/pre-commit", PRE_COMMIT);
+    fs.chmodSync(".githooks/pre-commit", 0o755);
+    console.log("✅ .githooks/pre-commit created  (ESLint + Jest coverage on staged files)");
+
+    fs.writeFileSync(".githooks/pre-push", PRE_PUSH);
+    fs.chmodSync(".githooks/pre-push", 0o755);
+    console.log("✅ .githooks/pre-push created    (Playwright smoke tests before every push)");
+
+    try {
+        execSync("git config core.hooksPath .githooks", { stdio: "pipe" });
+        console.log("✅ git configured to use .githooks/");
+    } catch (_) {
+        console.log("⚠️  Could not set core.hooksPath — run manually: git config core.hooksPath .githooks");
+    }
+
+    console.log(`
+Hooks installed. From now on:
+
+  git commit  →  ESLint errors on changed chunks block the commit
+                 Jest coverage < 80% on changed files blocks the commit
+
+  git push    →  Playwright smoke tests must all pass before push is allowed
+`);
+};

package/commands/init.js

@@ -0,0 +1,227 @@
+"use strict";
+
+const fs       = require("fs");
+const path     = require("path");
+const readline = require("readline");
+
+const PKG_ROOT = path.join(__dirname, "..");
+
+const FRAMEWORKS = [
+    { id: "react",   label: "React" },
+    { id: "nextjs",  label: "Next.js" },
+    { id: "vue",     label: "Vue / Nuxt" },
+    { id: "angular", label: "Angular" },
+    { id: "vanilla", label: "Vanilla JS / TypeScript" }
+];
+
+const CHECKS = [
+    { id: "eslint",     label: "ESLint      — code style and error rules on staged chunks" },
+    { id: "coverage",   label: "Coverage    — Jest line coverage (80% threshold per changed file)" },
+    { id: "playwright", label: "Playwright  — smoke tests run before every git push" }
+];
+
+const COPILOT_INSTRUCTIONS = {
+    react: `# React Quality Agent
+
+You are a Senior React Engineer embedded in this repository.
+
+## Your Responsibilities
+- Generate Jest + React Testing Library tests for every component and hook
+- Fix ESLint and TypeScript violations in staged files
+- Ensure 80% Jest line coverage on changed files
+- Generate Playwright tests for new pages and user flows
+
+## How to Work Efficiently
+Use the \`index\` MCP tool to find relevant components before answering.
+Use the \`read_file\` MCP tool to read only the specific file needed.
+Use the \`fix\` MCP tool when the user asks to fix quality issues.
+
+## Test Generation Rules — Jest + React Testing Library
+- File naming: \`{ComponentName}.test.tsx\`
+- Method naming: \`should {expected behavior} when {condition}\`
+- Cover: render output, user interactions, props, error boundaries, loading states
+- Use \`@testing-library/user-event\` for all user interactions (click, type, select)
+- Mock API calls with \`jest.fn()\` or \`msw\` (Mock Service Worker)
+- Use \`screen.getByRole\`, \`getByText\`, \`getByTestId\` — avoid querying by class/id
+
+## Test Generation Rules — Playwright
+- File naming: \`tests/{page-name}.spec.ts\`
+- Cover: happy path, form validation, navigation flows, error states
+- Use page object model pattern
+- Assertions: \`expect(locator).toBeVisible()\`, \`toHaveText()\`, \`toHaveURL()\`
+
+## Quality Standards
+- ESLint: react/recommended + typescript-eslint/recommended
+- No unused variables, no console.log in production code, no implicit \`any\`
+- Jest: 80% minimum line coverage on changed files
+- Playwright: all smoke tests must pass before every push
+`,
+    nextjs: `# Next.js Quality Agent
+
+You are a Senior Next.js Engineer embedded in this repository.
+
+## Your Responsibilities
+- Generate Jest + React Testing Library tests for components and API routes
+- Fix ESLint and TypeScript violations in staged files
+- Ensure 80% Jest line coverage on changed files
+- Generate Playwright tests for new pages
+
+## Test Generation Rules — Jest
+- File naming: \`{name}.test.tsx\` (components), \`{route}.test.ts\` (API routes)
+- For API routes: use \`NextRequest\` / \`NextResponse\` mocks
+- For server components: test the data-fetching logic separately from rendering
+- For client components: use React Testing Library same as React
+
+## Test Generation Rules — Playwright
+- File naming: \`tests/{page-name}.spec.ts\`
+- Cover: page navigation, SSR content visible, client-side transitions
+- Use \`page.goto()\` with full paths matching Next.js routing
+
+## Quality Standards
+- ESLint: next/core-web-vitals rules
+- No \`<img>\` — use Next.js \`<Image>\`
+- No \`<a>\` for internal links — use \`<Link>\`
+- Jest: 80% minimum line coverage
+`,
+    vue: `# Vue Quality Agent
+
+You are a Senior Vue Engineer embedded in this repository.
+
+## Your Responsibilities
+- Generate Jest + Vue Test Utils tests for every component
+- Fix ESLint and TypeScript violations in staged files
+- Ensure 80% Jest line coverage on changed files
+- Generate Playwright tests for new pages
+
+## Test Generation Rules — Jest
+- File naming: \`{ComponentName}.test.ts\`
+- Use \`mount\` for full rendering, \`shallowMount\` for unit isolation
+- Cover: props, emits, slots, user interactions, computed values
+- Mock Pinia stores with \`createTestingPinia()\`
+
+## Quality Standards
+- ESLint: vue3/recommended + TypeScript
+- Composition API only — no Options API
+- Jest: 80% minimum line coverage
+`,
+    angular: `# Angular Quality Agent
+
+You are a Senior Angular Engineer embedded in this repository.
+
+## Your Responsibilities
+- Generate Jest tests for components, services, guards, and pipes
+- Fix ESLint and TypeScript violations in staged files
+- Ensure 80% Jest line coverage on changed files
+
+## Test Generation Rules — Jest
+- File naming: \`{name}.spec.ts\`
+- Use \`TestBed.configureTestingModule()\` for component and service tests
+- Use \`HttpClientTestingModule\` + \`HttpTestingController\` for HTTP services
+- Cover: component rendering, service methods, guards, directive behavior
+
+## Quality Standards
+- ESLint: Angular recommended + TypeScript strict
+- Jest: 80% minimum line coverage
+`,
+    vanilla: `# Vanilla JS/TS Quality Agent
+
+You are a Senior JavaScript/TypeScript Engineer embedded in this repository.
+
+## Your Responsibilities
+- Generate Jest tests for every exported function and class
+- Fix ESLint and TypeScript violations in staged files
+- Ensure 80% Jest line coverage on changed files
+
+## Test Generation Rules — Jest
+- File naming: \`{module-name}.test.ts\`
+- Cover: return values, side effects, edge cases, thrown exceptions
+- Mock dependencies with \`jest.fn()\` and \`jest.spyOn()\`
+
+## Quality Standards
+- ESLint: recommended + TypeScript strict
+- Jest: 80% minimum line coverage
+`
+};
+
+function ask(rl, question) {
+    return new Promise(resolve => rl.question(question, resolve));
+}
+
+module.exports = async function init() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    console.log("\nreactjsquality-check911 — setup\n");
+
+    // ── Framework selection ───────────────────────────────────────────────────
+    console.log("Select your frontend framework:");
+    FRAMEWORKS.forEach((f, i) => console.log(`  ${i + 1}. ${f.label}`));
+    const fwRaw  = (await ask(rl, "\nEnter number (default: 1 — React): ")).trim() || "1";
+    const fwIdx  = parseInt(fwRaw) - 1;
+    const framework = FRAMEWORKS[fwIdx] || FRAMEWORKS[0];
+    console.log(`Selected: ${framework.label}\n`);
+
+    // ── Quality checks selection ──────────────────────────────────────────────
+    console.log("Select quality checks to enable:");
+    CHECKS.forEach((c, i) => console.log(`  ${i + 1}. ${c.label}`));
+    const checksRaw = (await ask(rl, "\nEnter numbers separated by commas (press Enter to enable all): ")).trim();
+    rl.close();
+
+    let selectedIds;
+    if (!checksRaw) {
+        selectedIds = CHECKS.map(c => c.id);
+    } else {
+        selectedIds = checksRaw.split(",").map(n => {
+            const idx = parseInt(n.trim()) - 1;
+            return CHECKS[idx] ? CHECKS[idx].id : null;
+        }).filter(Boolean);
+    }
+
+    const checks = {};
+    for (const c of CHECKS) checks[c.id] = selectedIds.includes(c.id);
+
+    // ── Write .reactjs-quality-agent.json ────────────────────────────────────
+    const config = { framework: framework.id, checks };
+    fs.writeFileSync(".reactjs-quality-agent.json", JSON.stringify(config, null, 2));
+    console.log("\n✅ .reactjs-quality-agent.json created");
+
+    // ── .github/copilot-instructions.md ──────────────────────────────────────
+    fs.mkdirSync(".github/instructions", { recursive: true });
+    const instructions = COPILOT_INSTRUCTIONS[framework.id] || COPILOT_INSTRUCTIONS.react;
+    fs.writeFileSync(".github/copilot-instructions.md", instructions);
+    console.log("✅ .github/copilot-instructions.md created");
+
+    // ── .vscode/mcp.json ─────────────────────────────────────────────────────
+    fs.mkdirSync(".vscode", { recursive: true });
+    const mcpServerPath = path.join(PKG_ROOT, "mcp-server", "server.py");
+    const mcpConfig = {
+        servers: {
+            "reactjs-quality-agent": {
+                type: "stdio",
+                command: "python",
+                args: [mcpServerPath],
+                env: {}
+            }
+        }
+    };
+    fs.writeFileSync(".vscode/mcp.json", JSON.stringify(mcpConfig, null, 2));
+    console.log("✅ .vscode/mcp.json configured");
+
+    // ── docs stubs ────────────────────────────────────────────────────────────
+    fs.mkdirSync("docs", { recursive: true });
+    if (!fs.existsSync("docs/architecture.md"))
+        fs.writeFileSync("docs/architecture.md", `# Frontend Architecture\n\nRun \`reactjsquality-check911 scan\` to generate this file.\n`);
+    if (!fs.existsSync("docs/component-index.md"))
+        fs.writeFileSync("docs/component-index.md", `# Component Index\n\nRun \`reactjsquality-check911 scan\` to generate this file.\n`);
+    console.log("✅ docs/ stubs created");
+
+    console.log(`
+Setup complete for ${framework.label}!
+
+Enabled checks:
+${Object.entries(checks).map(([k, v]) => `  ${v ? "✅" : "❌"}  ${k}`).join("\n")}
+
+Next steps:
+  reactjsquality-check911 scan     — index your components for Copilot
+  reactjsquality-check911 hooks    — install pre-commit and pre-push git hooks
+`);
+};

package/commands/playwright.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+
+const CONFIG_FILE = ".reactjs-quality-agent.json";
+
+module.exports = function playwright() {
+    const config = (() => {
+        try { return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")); } catch (_) { return null; }
+    })();
+
+    if (!config) {
+        console.error("No .reactjs-quality-agent.json found — run `reactjsquality-check911 init` first.");
+        process.exit(1);
+    }
+    if (!config.checks.playwright) {
+        console.log("Playwright check is disabled — skipping.");
+        return;
+    }
+
+    // Verify playwright is installed
+    if (!fs.existsSync("node_modules/.bin/playwright") && !fs.existsSync("node_modules/@playwright/test")) {
+        console.log("⚠️  Playwright not installed — skipping.");
+        console.log("   Run: npm install -D @playwright/test && npx playwright install");
+        return;
+    }
+
+    // Verify playwright config exists
+    const configFiles = ["playwright.config.ts", "playwright.config.js", "playwright.config.mjs"];
+    if (!configFiles.some(f => fs.existsSync(f))) {
+        console.log("⚠️  No playwright.config.ts found — skipping.");
+        console.log("   Run: npx playwright init");
+        return;
+    }
+
+    console.log("Running Playwright smoke tests...\n");
+
+    try {
+        const out = execSync("npx playwright test --reporter=list", {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        console.log(out);
+        console.log("✅ All Playwright tests passed.");
+    } catch (e) {
+        const output = (e.stdout || "") + (e.stderr || "");
+        console.log(output);
+        console.log("\n❌ Playwright tests failed — fix failing tests before pushing.");
+        process.exit(1);
+    }
+};

package/commands/quality.js

@@ -0,0 +1,158 @@
+"use strict";
+
+const { execSync } = require("child_process");
+const fs   = require("fs");
+const path = require("path");
+
+const CONFIG_FILE = ".reactjs-quality-agent.json";
+
+function loadConfig() {
+    try { return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8")); } catch (_) { return null; }
+}
+
+function getStagedFiles() {
+    try {
+        const out = execSync("git diff --cached --name-only", { encoding: "utf8" });
+        return out.split("\n").map(f => f.trim())
+            .filter(f => f && /\.(js|jsx|ts|tsx|vue|svelte)$/.test(f) && fs.existsSync(f));
+    } catch (_) { return []; }
+}
+
+function getChangedLineRanges() {
+    try {
+        const diff = execSync("git diff --cached --unified=0", { encoding: "utf8" });
+        const ranges = {};
+        let cur = null;
+        for (const line of diff.split("\n")) {
+            const fileM = /^\+\+\+ b\/(.+)$/.exec(line);
+            if (fileM) { cur = fileM[1]; if (!ranges[cur]) ranges[cur] = []; continue; }
+            if (line.startsWith("+++ /dev/null")) { cur = null; continue; }
+            const hunkM = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(line);
+            if (hunkM && cur) {
+                const start = parseInt(hunkM[1]);
+                const count = hunkM[2] !== undefined ? parseInt(hunkM[2]) : 1;
+                if (count > 0) ranges[cur].push([start, start + count - 1]);
+            }
+        }
+        return ranges;
+    } catch (_) { return {}; }
+}
+
+function findRanges(filePath, changedRanges) {
+    const norm = filePath.replace(/\\/g, "/").toLowerCase();
+    for (const [gitPath, ranges] of Object.entries(changedRanges)) {
+        const gn = gitPath.toLowerCase();
+        if (norm === gn || norm.endsWith("/" + gn)) return ranges;
+    }
+    return null;
+}
+
+function inChangedRange(lineNum, ranges) {
+    if (!ranges || isNaN(lineNum)) return false;
+    return ranges.some(([s, e]) => lineNum >= s && lineNum <= e);
+}
+
+function runEslint(staged, changedRanges) {
+    process.stdout.write("Running ESLint...     ");
+    try {
+        const fileArgs = staged.map(f => `"${f}"`).join(" ");
+        let output = "";
+        try {
+            output = execSync(`npx eslint ${fileArgs} --format json`, {
+                encoding: "utf8", stdio: ["pipe", "pipe", "pipe"]
+            });
+        } catch (e) {
+            // ESLint exits with code 1 when violations found — stdout still has JSON
+            output = e.stdout || "[]";
+        }
+
+        const data   = JSON.parse(output || "[]");
+        const viols  = [];
+        const errors = [];
+
+        for (const file of data) {
+            const ranges = findRanges(file.filePath, changedRanges);
+            if (!ranges) continue;
+            for (const msg of file.messages) {
+                if (!inChangedRange(msg.line, ranges)) continue;
+                const label = msg.severity === 2 ? "error" : "warn";
+                const entry = `  [ESLint:${msg.ruleId || "unknown"}] ${path.basename(file.filePath)}:${msg.line} — ${msg.message} (${label})`;
+                viols.push(entry);
+                if (msg.severity === 2) errors.push(entry);
+            }
+        }
+
+        if (errors.length) {
+            console.log("❌");
+            viols.forEach(v => console.log(v));
+            return { passed: false, summary: `❌ ESLint: ${errors.length} error(s) in your changed lines` };
+        }
+        console.log("✅");
+        if (viols.length) viols.forEach(v => console.log(v)); // show warnings only
+        return { passed: true, summary: "✅ ESLint passed" };
+    } catch (e) {
+        console.log("⚠️");
+        return { passed: true, summary: "⚠️  ESLint: not installed — run `npm install eslint` in your project" };
+    }
+}
+
+function runTypeScript(staged) {
+    const tsFiles = staged.filter(f => f.endsWith(".ts") || f.endsWith(".tsx"));
+    process.stdout.write("Running TypeScript... ");
+    if (!tsFiles.length) {
+        console.log("✅ (no TS files staged)");
+        return { passed: true, summary: "✅ TypeScript: no TS files staged" };
+    }
+    try {
+        execSync("npx tsc --noEmit", { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+        console.log("✅");
+        return { passed: true, summary: "✅ TypeScript passed" };
+    } catch (e) {
+        const lines = ((e.stdout || "") + (e.stderr || ""))
+            .split("\n").filter(l => l.includes("error TS")).slice(0, 5);
+        console.log("❌");
+        lines.forEach(l => console.log(" ", l.trim()));
+        return { passed: false, summary: "❌ TypeScript: type errors found" };
+    }
+}
+
+module.exports = function quality() {
+    const config = loadConfig();
+    if (!config) {
+        console.error("No .reactjs-quality-agent.json found — run `reactjsquality-check911 init` first.");
+        process.exit(1);
+    }
+
+    const staged = getStagedFiles();
+    if (!staged.length) {
+        console.log("No staged JS/TS files — skipping quality checks.");
+        return;
+    }
+
+    const changedRanges = getChangedLineRanges();
+    console.log(`Checking changed chunks in: ${staged.map(f => path.basename(f)).join(", ")}\n`);
+
+    const results = [];
+    let failed    = false;
+
+    if (config.checks.eslint !== false) {
+        const r = runEslint(staged, changedRanges);
+        results.push(r.summary);
+        if (!r.passed) failed = true;
+    }
+
+    const r2 = runTypeScript(staged);
+    results.push(r2.summary);
+    if (!r2.passed) failed = true;
+
+    console.log("\n--- Quality Summary ---");
+    results.forEach(r => console.log(r));
+
+    if (failed) {
+        console.log("\nFix violations and commit again, or ask Copilot:");
+        console.log("  'Fix the quality violations in my staged files'");
+        process.exit(1);
+    }
+
+    console.log("\nAll quality checks passed.");
+};