apex-auditor 0.1.1 → 0.1.3

package/dist/lighthouse-runner.js

@@ -1,10 +1,10 @@
 import lighthouse from "lighthouse";
-import chromeLauncher from "chrome-launcher";
+import { launch as launchChrome } from "chrome-launcher";
 async function createChromeSession(chromePort) {
     if (typeof chromePort === "number") {
         return { port: chromePort };
     }
-    const chrome = await chromeLauncher.launch({
+    const chrome = await launchChrome({
         chromeFlags: [
             "--headless=new",
             "--disable-gpu",

package/dist/project-discovery.js

@@ -0,0 +1,92 @@
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { pathExists } from "./fs-utils.js";
+const DEFAULT_MAX_DEPTH = 3;
+const IGNORED_DIRECTORIES = [
+    "node_modules",
+    ".git",
+    ".next",
+    ".turbo",
+    ".vercel",
+    "dist",
+    "build",
+    "out",
+    "coverage",
+    ".cache",
+];
+/**
+ * Discover Next.js projects below the given repository root.
+ * This performs a shallow breadth-first search and looks for either
+ * a next.config.* file or a package.json that depends on "next".
+ */
+export async function discoverNextProjects(options) {
+    const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const queue = [{ path: options.repoRoot, depth: 0 }];
+    const visited = new Set();
+    const projects = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current.path)) {
+            continue;
+        }
+        visited.add(current.path);
+        if (await isNextProjectRoot(current.path)) {
+            const name = basename(current.path) || ".";
+            projects.push({ name, root: current.path, framework: "next" });
+            continue;
+        }
+        if (current.depth >= maxDepth) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await readdir(current.path, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (IGNORED_DIRECTORIES.includes(entry.name)) {
+                continue;
+            }
+            const childPath = join(current.path, entry.name);
+            queue.push({ path: childPath, depth: current.depth + 1 });
+        }
+    }
+    return projects;
+}
+async function isNextProjectRoot(directory) {
+    const nextConfigCandidates = [
+        "next.config.js",
+        "next.config.mjs",
+        "next.config.cjs",
+        "next.config.ts",
+    ];
+    for (const candidate of nextConfigCandidates) {
+        const configPath = join(directory, candidate);
+        if (await pathExists(configPath)) {
+            return true;
+        }
+    }
+    const packageJsonPath = join(directory, "package.json");
+    if (!(await pathExists(packageJsonPath))) {
+        return false;
+    }
+    try {
+        const raw = await readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return false;
+        }
+        const maybePackage = parsed;
+        const hasNextDependency = Boolean((maybePackage.dependencies && typeof maybePackage.dependencies.next === "string") ||
+            (maybePackage.devDependencies && typeof maybePackage.devDependencies.next === "string"));
+        return hasNextDependency;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/route-detectors.js

@@ -42,15 +42,43 @@ export async function detectRoutes(options) {
 function createNextAppDetector() {
     return {
         id: SOURCE_NEXT_APP,
-        canDetect: async (options) => pathExists(join(options.projectRoot, "app")),
-        detect: async (options) => detectAppRoutes(join(options.projectRoot, "app"), options.limit),
+        canDetect: async (options) => {
+            const roots = await findNextAppRoots(options.projectRoot);
+            return roots.length > 0;
+        },
+        detect: async (options) => {
+            const roots = await findNextAppRoots(options.projectRoot);
+            const allRoutes = [];
+            for (const root of roots) {
+                const routes = await detectAppRoutes(root, options.limit);
+                allRoutes.push(...routes);
+                if (allRoutes.length >= options.limit) {
+                    break;
+                }
+            }
+            return allRoutes;
+        },
     };
 }
 function createNextPagesDetector() {
     return {
         id: SOURCE_NEXT_PAGES,
-        canDetect: async (options) => pathExists(join(options.projectRoot, "pages")),
-        detect: async (options) => detectPagesRoutes(join(options.projectRoot, "pages"), options.limit),
+        canDetect: async (options) => {
+            const roots = await findNextPagesRoots(options.projectRoot);
+            return roots.length > 0;
+        },
+        detect: async (options) => {
+            const roots = await findNextPagesRoots(options.projectRoot);
+            const allRoutes = [];
+            for (const root of roots) {
+                const routes = await detectPagesRoutes(root, options.limit);
+                allRoutes.push(...routes);
+                if (allRoutes.length >= options.limit) {
+                    break;
+                }
+            }
+            return allRoutes;
+        },
     };
 }
 function createRemixRoutesDetector() {
@@ -67,6 +95,90 @@ function createSpaHtmlDetector() {
         detect: async (options) => detectSpaRoutes(options.projectRoot, options.limit),
     };
 }
+async function findNextAppRoots(projectRoot) {
+    const roots = [];
+    const seen = new Set();
+    const addRoot = (candidate) => {
+        if (!seen.has(candidate)) {
+            seen.add(candidate);
+            roots.push(candidate);
+        }
+    };
+    const directCandidates = [
+        join(projectRoot, "app"),
+        join(projectRoot, "src", "app"),
+    ];
+    for (const candidate of directCandidates) {
+        if (await pathExists(candidate)) {
+            addRoot(candidate);
+        }
+    }
+    const containers = ["apps", "packages"];
+    for (const container of containers) {
+        const containerPath = join(projectRoot, container);
+        if (!(await pathExists(containerPath))) {
+            continue;
+        }
+        const entries = await readdir(containerPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const appRoot = join(containerPath, entry.name, "app");
+            const srcAppRoot = join(containerPath, entry.name, "src", "app");
+            if (await pathExists(appRoot)) {
+                addRoot(appRoot);
+                continue;
+            }
+            if (await pathExists(srcAppRoot)) {
+                addRoot(srcAppRoot);
+            }
+        }
+    }
+    return roots;
+}
+async function findNextPagesRoots(projectRoot) {
+    const roots = [];
+    const seen = new Set();
+    const addRoot = (candidate) => {
+        if (!seen.has(candidate)) {
+            seen.add(candidate);
+            roots.push(candidate);
+        }
+    };
+    const directCandidates = [
+        join(projectRoot, "pages"),
+        join(projectRoot, "src", "pages"),
+    ];
+    for (const candidate of directCandidates) {
+        if (await pathExists(candidate)) {
+            addRoot(candidate);
+        }
+    }
+    const containers = ["apps", "packages"];
+    for (const container of containers) {
+        const containerPath = join(projectRoot, container);
+        if (!(await pathExists(containerPath))) {
+            continue;
+        }
+        const entries = await readdir(containerPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const pagesRoot = join(containerPath, entry.name, "pages");
+            const srcPagesRoot = join(containerPath, entry.name, "src", "pages");
+            if (await pathExists(pagesRoot)) {
+                addRoot(pagesRoot);
+                continue;
+            }
+            if (await pathExists(srcPagesRoot)) {
+                addRoot(srcPagesRoot);
+            }
+        }
+    }
+    return roots;
+}
 async function detectAppRoutes(appRoot, limit) {
     const files = await collectRouteFiles(appRoot, limit, isAppPageFile);
     return files.map((file) => buildRoute(file, appRoot, formatAppRoutePath, SOURCE_NEXT_APP));

package/dist/wizard-cli.js

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import prompts from "prompts";
 import { detectRoutes } from "./route-detectors.js";
 import { pathExists } from "./fs-utils.js";
+import { discoverNextProjects } from "./project-discovery.js";
 const PROFILE_TO_DETECTOR = {
     "next-app": "next-app",
     "next-pages": "next-pages",
@@ -194,18 +195,44 @@ async function maybeDetectPages(profile) {
     }
     const preferredDetector = await selectDetector(profile);
     const projectRootAnswer = await ask(projectRootQuestion);
-    const absoluteRoot = resolve(projectRootAnswer.projectRoot);
-    if (!(await pathExists(absoluteRoot))) {
-        console.log(`No project found at ${absoluteRoot}. Skipping auto-detection.`);
+    const repoRoot = resolve(projectRootAnswer.projectRoot);
+    if (!(await pathExists(repoRoot))) {
+        console.log(`No project found at ${repoRoot}. Skipping auto-detection.`);
         return [];
     }
-    const routes = await detectRoutes({ projectRoot: absoluteRoot, preferredDetectorId: preferredDetector });
+    const detectionRoot = await chooseDetectionRoot({ profile, repoRoot });
+    const routes = await detectRoutes({ projectRoot: detectionRoot, preferredDetectorId: preferredDetector });
     if (routes.length === 0) {
         console.log("No routes detected. Add pages manually.");
         return [];
     }
     return selectDetectedRoutes(routes);
 }
+async function chooseDetectionRoot({ profile, repoRoot, }) {
+    if (profile !== "next-app" && profile !== "next-pages") {
+        return repoRoot;
+    }
+    const projects = await discoverNextProjects({ repoRoot });
+    if (projects.length === 0) {
+        return repoRoot;
+    }
+    if (projects.length === 1) {
+        const onlyProject = projects[0];
+        console.log(`Detected Next.js app at ${onlyProject.root}.`);
+        return onlyProject.root;
+    }
+    const choices = projects.map((project) => ({
+        title: `${project.name} (${project.root})`,
+        value: project.root,
+    }));
+    const answer = await ask({
+        type: "select",
+        name: "projectRoot",
+        message: "Multiple Next.js apps found. Which one do you want to audit?",
+        choices,
+    });
+    return answer.projectRoot ?? repoRoot;
+}
 async function selectDetector(profile) {
     const preset = PROFILE_TO_DETECTOR[profile];
     if (preset) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apex-auditor",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "description": "CLI to run structured Lighthouse audits (Performance, Accessibility, Best Practices, SEO) across routes.",
   "type": "module",
@@ -18,8 +18,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "chrome-launcher": "^0.15.2",
-    "lighthouse": "^12.6.1",
+    "chrome-launcher": "^1.2.1",
+    "lighthouse": "^13.0.1",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
@@ -27,6 +27,6 @@
     "typescript": "^5.9.3",
     "@types/node": "^22.0.0",
     "@types/prompts": "^2.4.9",
-    "vitest": "^1.3.1"
+    "vitest": "^4.0.14"
   }
 }