@qulib/core 0.1.0

package/dist/schemas/route-inventory.schema.d.ts

@@ -0,0 +1,241 @@
+import { z } from 'zod';
+export declare const A11yViolationSchema: z.ZodObject<{
+    id: z.ZodString;
+    impact: z.ZodString;
+    helpUrl: z.ZodString;
+    nodeCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    impact: string;
+    helpUrl: string;
+    nodeCount: number;
+}, {
+    id: string;
+    impact: string;
+    helpUrl: string;
+    nodeCount: number;
+}>;
+export declare const BrokenLinkSchema: z.ZodObject<{
+    url: z.ZodString;
+    status: z.ZodNullable<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: number | null;
+    url: string;
+    reason?: string | undefined;
+}, {
+    status: number | null;
+    url: string;
+    reason?: string | undefined;
+}>;
+export declare const RouteSchema: z.ZodObject<{
+    path: z.ZodString;
+    pageTitle: z.ZodString;
+    links: z.ZodArray<z.ZodString, "many">;
+    formCount: z.ZodNumber;
+    buttonLabels: z.ZodArray<z.ZodString, "many">;
+    consoleErrors: z.ZodArray<z.ZodString, "many">;
+    brokenLinks: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        status: z.ZodNullable<z.ZodNumber>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: number | null;
+        url: string;
+        reason?: string | undefined;
+    }, {
+        status: number | null;
+        url: string;
+        reason?: string | undefined;
+    }>, "many">;
+    a11yViolations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        impact: z.ZodString;
+        helpUrl: z.ZodString;
+        nodeCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        impact: string;
+        helpUrl: string;
+        nodeCount: number;
+    }, {
+        id: string;
+        impact: string;
+        helpUrl: string;
+        nodeCount: number;
+    }>, "many">;
+    statusCode: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    pageTitle: string;
+    links: string[];
+    formCount: number;
+    buttonLabels: string[];
+    consoleErrors: string[];
+    brokenLinks: {
+        status: number | null;
+        url: string;
+        reason?: string | undefined;
+    }[];
+    a11yViolations: {
+        id: string;
+        impact: string;
+        helpUrl: string;
+        nodeCount: number;
+    }[];
+    statusCode?: number | undefined;
+}, {
+    path: string;
+    pageTitle: string;
+    links: string[];
+    formCount: number;
+    buttonLabels: string[];
+    consoleErrors: string[];
+    brokenLinks: {
+        status: number | null;
+        url: string;
+        reason?: string | undefined;
+    }[];
+    a11yViolations: {
+        id: string;
+        impact: string;
+        helpUrl: string;
+        nodeCount: number;
+    }[];
+    statusCode?: number | undefined;
+}>;
+export declare const RouteInventorySchema: z.ZodObject<{
+    scannedAt: z.ZodString;
+    baseUrl: z.ZodString;
+    routes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        pageTitle: z.ZodString;
+        links: z.ZodArray<z.ZodString, "many">;
+        formCount: z.ZodNumber;
+        buttonLabels: z.ZodArray<z.ZodString, "many">;
+        consoleErrors: z.ZodArray<z.ZodString, "many">;
+        brokenLinks: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            status: z.ZodNullable<z.ZodNumber>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            status: number | null;
+            url: string;
+            reason?: string | undefined;
+        }, {
+            status: number | null;
+            url: string;
+            reason?: string | undefined;
+        }>, "many">;
+        a11yViolations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            impact: z.ZodString;
+            helpUrl: z.ZodString;
+            nodeCount: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            impact: string;
+            helpUrl: string;
+            nodeCount: number;
+        }, {
+            id: string;
+            impact: string;
+            helpUrl: string;
+            nodeCount: number;
+        }>, "many">;
+        statusCode: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        pageTitle: string;
+        links: string[];
+        formCount: number;
+        buttonLabels: string[];
+        consoleErrors: string[];
+        brokenLinks: {
+            status: number | null;
+            url: string;
+            reason?: string | undefined;
+        }[];
+        a11yViolations: {
+            id: string;
+            impact: string;
+            helpUrl: string;
+            nodeCount: number;
+        }[];
+        statusCode?: number | undefined;
+    }, {
+        path: string;
+        pageTitle: string;
+        links: string[];
+        formCount: number;
+        buttonLabels: string[];
+        consoleErrors: string[];
+        brokenLinks: {
+            status: number | null;
+            url: string;
+            reason?: string | undefined;
+        }[];
+        a11yViolations: {
+            id: string;
+            impact: string;
+            helpUrl: string;
+            nodeCount: number;
+        }[];
+        statusCode?: number | undefined;
+    }>, "many">;
+    pagesSkipped: z.ZodNumber;
+    budgetExceeded: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    scannedAt: string;
+    baseUrl: string;
+    routes: {
+        path: string;
+        pageTitle: string;
+        links: string[];
+        formCount: number;
+        buttonLabels: string[];
+        consoleErrors: string[];
+        brokenLinks: {
+            status: number | null;
+            url: string;
+            reason?: string | undefined;
+        }[];
+        a11yViolations: {
+            id: string;
+            impact: string;
+            helpUrl: string;
+            nodeCount: number;
+        }[];
+        statusCode?: number | undefined;
+    }[];
+    pagesSkipped: number;
+    budgetExceeded: boolean;
+}, {
+    scannedAt: string;
+    baseUrl: string;
+    routes: {
+        path: string;
+        pageTitle: string;
+        links: string[];
+        formCount: number;
+        buttonLabels: string[];
+        consoleErrors: string[];
+        brokenLinks: {
+            status: number | null;
+            url: string;
+            reason?: string | undefined;
+        }[];
+        a11yViolations: {
+            id: string;
+            impact: string;
+            helpUrl: string;
+            nodeCount: number;
+        }[];
+        statusCode?: number | undefined;
+    }[];
+    pagesSkipped: number;
+    budgetExceeded: boolean;
+}>;
+export type RouteInventory = z.infer<typeof RouteInventorySchema>;
+export type Route = z.infer<typeof RouteSchema>;
+//# sourceMappingURL=route-inventory.schema.d.ts.map

package/dist/schemas/route-inventory.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-inventory.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/route-inventory.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUtB,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/schemas/route-inventory.schema.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export const A11yViolationSchema = z.object({
+    id: z.string(),
+    impact: z.string(),
+    helpUrl: z.string(),
+    nodeCount: z.number().int(),
+});
+export const BrokenLinkSchema = z.object({
+    url: z.string(),
+    status: z.number().nullable(),
+    reason: z.string().optional(),
+});
+export const RouteSchema = z.object({
+    path: z.string(),
+    pageTitle: z.string(),
+    links: z.array(z.string()),
+    formCount: z.number().int(),
+    buttonLabels: z.array(z.string()),
+    consoleErrors: z.array(z.string()),
+    brokenLinks: z.array(BrokenLinkSchema),
+    a11yViolations: z.array(A11yViolationSchema),
+    statusCode: z.number().int().optional(),
+});
+export const RouteInventorySchema = z.object({
+    scannedAt: z.string().datetime(),
+    baseUrl: z.string().url(),
+    routes: z.array(RouteSchema),
+    pagesSkipped: z.number().int(),
+    budgetExceeded: z.boolean(),
+});

package/dist/tools/auth.d.ts

@@ -0,0 +1,4 @@
+import type { Browser, BrowserContext } from '@playwright/test';
+import type { AuthConfig } from '../schemas/config.schema.js';
+export declare function createAuthenticatedContext(browser: Browser, auth: AuthConfig | undefined, timeoutMs: number): Promise<BrowserContext>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/tools/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/tools/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC,CAsCzB"}

package/dist/tools/auth.js

@@ -0,0 +1,35 @@
+import { resolve } from 'node:path';
+export async function createAuthenticatedContext(browser, auth, timeoutMs) {
+    if (!auth) {
+        return browser.newContext();
+    }
+    if (auth.type === 'storage-state') {
+        const storagePath = resolve(process.cwd(), auth.path);
+        return browser.newContext({ storageState: storagePath });
+    }
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    try {
+        await page.goto(auth.loginUrl, { timeout: timeoutMs, waitUntil: 'domcontentloaded' });
+        await page.fill(auth.selectors.username, auth.credentials.username);
+        await page.fill(auth.selectors.password, auth.credentials.password);
+        await page.click(auth.selectors.submit);
+        const urlFragment = auth.successIndicator.urlContains;
+        if (urlFragment) {
+            await page.waitForURL((url) => url.toString().includes(urlFragment), {
+                timeout: timeoutMs,
+            });
+        }
+        const visibleSelector = auth.successIndicator.selectorVisible;
+        if (visibleSelector) {
+            await page.waitForSelector(visibleSelector, {
+                timeout: timeoutMs,
+                state: 'visible',
+            });
+        }
+    }
+    finally {
+        await page.close();
+    }
+    return context;
+}

package/dist/tools/cypress-explorer.d.ts

@@ -0,0 +1,7 @@
+import type { AppExplorer } from './explorer.interface.js';
+import type { HarnessConfig } from '../schemas/config.schema.js';
+import type { RouteInventory } from '../schemas/route-inventory.schema.js';
+export declare class CypressExplorer implements AppExplorer {
+    explore(baseUrl: string, config: HarnessConfig): Promise<RouteInventory>;
+}
+//# sourceMappingURL=cypress-explorer.d.ts.map

package/dist/tools/cypress-explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cypress-explorer.d.ts","sourceRoot":"","sources":["../../src/tools/cypress-explorer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAE3E,qBAAa,eAAgB,YAAW,WAAW;IAC3C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CAG/E"}

package/dist/tools/cypress-explorer.js

@@ -0,0 +1,5 @@
+export class CypressExplorer {
+    async explore(baseUrl, config) {
+        throw new Error('Not implemented');
+    }
+}

package/dist/tools/explorer-factory.d.ts

@@ -0,0 +1,4 @@
+import type { ExplorerType } from '../schemas/config.schema.js';
+import type { AppExplorer } from './explorer.interface.js';
+export declare function createExplorer(type: ExplorerType): AppExplorer;
+//# sourceMappingURL=explorer-factory.d.ts.map

package/dist/tools/explorer-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorer-factory.d.ts","sourceRoot":"","sources":["../../src/tools/explorer-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAI3D,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,WAAW,CAS9D"}

package/dist/tools/explorer-factory.js

@@ -0,0 +1,12 @@
+import { PlaywrightExplorer } from './playwright-explorer.js';
+import { CypressExplorer } from './cypress-explorer.js';
+export function createExplorer(type) {
+    switch (type) {
+        case 'playwright':
+            return new PlaywrightExplorer();
+        case 'cypress':
+            return new CypressExplorer();
+        default:
+            throw new Error(`Unknown explorer type: ${type}`);
+    }
+}

package/dist/tools/explorer.interface.d.ts

@@ -0,0 +1,6 @@
+import type { HarnessConfig } from '../schemas/config.schema.js';
+import type { RouteInventory } from '../schemas/route-inventory.schema.js';
+export interface AppExplorer {
+    explore(baseUrl: string, config: HarnessConfig): Promise<RouteInventory>;
+}
+//# sourceMappingURL=explorer.interface.d.ts.map

package/dist/tools/explorer.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorer.interface.d.ts","sourceRoot":"","sources":["../../src/tools/explorer.interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAE3E,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAC1E"}

package/dist/tools/explorer.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/gap-engine.d.ts

@@ -0,0 +1,6 @@
+import { type GapAnalysis } from '../schemas/gap-analysis.schema.js';
+import type { RouteInventory } from '../schemas/route-inventory.schema.js';
+import type { RepoAnalysis } from '../schemas/repo-analysis.schema.js';
+import type { HarnessConfig } from '../schemas/config.schema.js';
+export declare function analyzeGaps(routes: RouteInventory, repo: RepoAnalysis | null, mode: 'url-only' | 'url-repo', config: HarnessConfig): Omit<GapAnalysis, 'scenarios' | 'generatedTests'>;
+//# sourceMappingURL=gap-engine.d.ts.map

package/dist/tools/gap-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gap-engine.d.ts","sourceRoot":"","sources":["../../src/tools/gap-engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,WAAW,EAAY,MAAM,mCAAmC,CAAC;AAC1F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAC3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,wBAAgB,WAAW,CACzB,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,YAAY,GAAG,IAAI,EACzB,IAAI,EAAE,UAAU,GAAG,UAAU,EAC7B,MAAM,EAAE,aAAa,GACpB,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,gBAAgB,CAAC,CA0GnD"}

package/dist/tools/gap-engine.js

@@ -0,0 +1,101 @@
+import { randomUUID } from 'node:crypto';
+import { GapSchema } from '../schemas/gap-analysis.schema.js';
+export function analyzeGaps(routes, repo, mode, config) {
+    const coveredPaths = new Set();
+    if (repo) {
+        for (const testFile of repo.testFiles) {
+            for (const path of testFile.coveredPaths) {
+                coveredPaths.add(path);
+            }
+        }
+    }
+    const gaps = [];
+    const addGap = (gap) => {
+        const validated = GapSchema.parse(gap);
+        gaps.push(validated);
+    };
+    let hasNavigationFailures = false;
+    for (const route of routes.routes) {
+        if (repo && !coveredPaths.has(route.path)) {
+            const highRisk = /checkout|payment|auth|login|order/i.test(route.path);
+            addGap({
+                id: randomUUID(),
+                path: route.path,
+                severity: highRisk ? 'high' : 'medium',
+                reason: `Route is not covered by existing tests: ${route.path}`,
+                category: 'untested-route',
+            });
+        }
+        const navErrors = route.consoleErrors.filter((e) => e.startsWith('Navigation error:'));
+        if (navErrors.length > 0) {
+            hasNavigationFailures = true;
+            addGap({
+                id: randomUUID(),
+                path: route.path,
+                severity: 'high',
+                reason: `Navigation failed: ${navErrors.join('; ')}`,
+                category: 'console-error',
+            });
+        }
+        else if (route.consoleErrors.length > 0) {
+            addGap({
+                id: randomUUID(),
+                path: route.path,
+                severity: 'high',
+                reason: `Console errors detected (${route.consoleErrors.length})`,
+                category: 'console-error',
+            });
+        }
+        if (route.brokenLinks.length > 0) {
+            addGap({
+                id: randomUUID(),
+                path: route.path,
+                severity: 'medium',
+                reason: `Broken or invalid links detected (${route.brokenLinks.length})`,
+                category: 'broken-link',
+            });
+        }
+        for (const violation of route.a11yViolations) {
+            const impact = violation.impact.toLowerCase();
+            const severity = impact === 'critical' || impact === 'serious'
+                ? 'high'
+                : impact === 'moderate'
+                    ? 'medium'
+                    : 'low';
+            addGap({
+                id: randomUUID(),
+                path: route.path,
+                severity,
+                reason: `A11y violation ${violation.id} (${violation.impact}): ${violation.helpUrl}`,
+                category: 'a11y',
+            });
+        }
+    }
+    const highCount = gaps.filter((g) => g.severity === 'high').length;
+    const mediumCount = gaps.filter((g) => g.severity === 'medium').length;
+    const lowCount = gaps.filter((g) => g.severity === 'low').length;
+    let releaseConfidence = Math.max(0, 100 - highCount * 20 - mediumCount * 8 - lowCount * 3);
+    const pagesScanned = routes.routes.length;
+    if (pagesScanned < config.minPagesForConfidence) {
+        releaseConfidence = Math.min(releaseConfidence, 40);
+    }
+    let coverageWarning;
+    if (routes.budgetExceeded) {
+        coverageWarning = 'budget-exceeded';
+    }
+    else if (hasNavigationFailures) {
+        coverageWarning = 'navigation-failures';
+    }
+    else if (pagesScanned < config.minPagesForConfidence) {
+        coverageWarning = 'low-coverage';
+    }
+    return {
+        analyzedAt: new Date().toISOString(),
+        mode,
+        releaseConfidence,
+        coveragePagesScanned: pagesScanned,
+        coverageBudgetExceeded: routes.budgetExceeded,
+        coverageWarning,
+        gaps,
+    };
+}

package/dist/tools/playwright-explorer.d.ts

@@ -0,0 +1,7 @@
+import type { AppExplorer } from './explorer.interface.js';
+import { type RouteInventory } from '../schemas/route-inventory.schema.js';
+import type { HarnessConfig } from '../schemas/config.schema.js';
+export declare class PlaywrightExplorer implements AppExplorer {
+    explore(baseUrl: string, config: HarnessConfig): Promise<RouteInventory>;
+}
+//# sourceMappingURL=playwright-explorer.d.ts.map

package/dist/tools/playwright-explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-explorer.d.ts","sourceRoot":"","sources":["../../src/tools/playwright-explorer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EAAwB,KAAK,cAAc,EAAc,MAAM,sCAAsC,CAAC;AAC7G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,qBAAa,kBAAmB,YAAW,WAAW;IAC9C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;CA6J/E"}

package/dist/tools/playwright-explorer.js

@@ -0,0 +1,150 @@
+import { chromium } from '@playwright/test';
+import { AxeBuilder } from '@axe-core/playwright';
+import { createAuthenticatedContext } from './auth.js';
+import { RouteInventorySchema } from '../schemas/route-inventory.schema.js';
+export class PlaywrightExplorer {
+    async explore(baseUrl, config) {
+        const browser = await chromium.launch({ headless: true });
+        let context;
+        try {
+            context = await createAuthenticatedContext(browser, config.auth, config.timeoutMs);
+        }
+        catch (err) {
+            await browser.close();
+            throw new Error(`Authentication failed: ${String(err)}. Check your auth config and credentials.`);
+        }
+        if (config.auth) {
+            const label = config.auth.type === 'form-login' ? config.auth.credentials.username : 'storage-state';
+            console.error(`[qulib] authenticated as ${label}`);
+        }
+        const visited = new Set();
+        const queue = [baseUrl];
+        const routes = [];
+        let budgetExceeded = false;
+        try {
+            while (queue.length > 0) {
+                if (visited.size >= config.maxPagesToScan) {
+                    budgetExceeded = queue.length > 0;
+                    break;
+                }
+                const url = queue.shift();
+                if (!url) {
+                    continue;
+                }
+                const normalized = url.split('?')[0].split('#')[0];
+                if (visited.has(normalized))
+                    continue;
+                visited.add(normalized);
+                const page = await context.newPage();
+                const consoleErrors = [];
+                page.on('console', (msg) => {
+                    if (msg.type() === 'error') {
+                        consoleErrors.push(msg.text());
+                    }
+                });
+                try {
+                    await page.goto(url, {
+                        timeout: config.timeoutMs,
+                        waitUntil: 'domcontentloaded',
+                    });
+                    const pageTitle = await page.title();
+                    const formCount = await page.locator('form').count();
+                    const buttonLabels = await page.locator('button').allInnerTexts();
+                    const hrefs = await page.evaluate(() => Array.from(document.querySelectorAll('a[href]'))
+                        .map((a) => a.href)
+                        .filter(Boolean));
+                    const base = new URL(baseUrl);
+                    const internalLinks = hrefs
+                        .filter((href) => {
+                        try {
+                            const u = new URL(href);
+                            return u.origin === base.origin;
+                        }
+                        catch {
+                            return false;
+                        }
+                    })
+                        .map((href) => href.split('?')[0].split('#')[0]);
+                    const uniqueInternal = [...new Set(internalLinks)];
+                    for (const link of uniqueInternal) {
+                        if (!visited.has(link) && !queue.includes(link)) {
+                            queue.push(link);
+                        }
+                    }
+                    const brokenLinks = [];
+                    for (const link of uniqueInternal.slice(0, 20)) {
+                        try {
+                            const response = await page.request.head(link, { timeout: 5000 });
+                            if (response.status() >= 400) {
+                                brokenLinks.push({ url: link, status: response.status() });
+                            }
+                        }
+                        catch (err) {
+                            brokenLinks.push({ url: link, status: null, reason: String(err) });
+                        }
+                    }
+                    let a11yViolations = [];
+                    try {
+                        const axeResults = await new AxeBuilder({ page })
+                            .withTags(['wcag2a', 'wcag2aa'])
+                            .analyze();
+                        a11yViolations = axeResults.violations.map((v) => ({
+                            id: v.id,
+                            impact: v.impact ?? 'unknown',
+                            helpUrl: v.helpUrl,
+                            nodeCount: v.nodes.length,
+                        }));
+                    }
+                    catch (err) {
+                        consoleErrors.push(`axe-core failure: ${String(err)}`);
+                    }
+                    const path = new URL(url).pathname || '/';
+                    routes.push({
+                        path,
+                        pageTitle,
+                        links: uniqueInternal,
+                        formCount,
+                        buttonLabels: buttonLabels.map((b) => b.trim()).filter(Boolean),
+                        consoleErrors,
+                        brokenLinks,
+                        a11yViolations,
+                    });
+                }
+                catch (err) {
+                    const path = (() => {
+                        try {
+                            return new URL(url).pathname || '/';
+                        }
+                        catch {
+                            return url;
+                        }
+                    })();
+                    routes.push({
+                        path,
+                        pageTitle: '',
+                        links: [],
+                        formCount: 0,
+                        buttonLabels: [],
+                        consoleErrors: [`Navigation error: ${String(err)}`],
+                        brokenLinks: [],
+                        a11yViolations: [],
+                    });
+                }
+                finally {
+                    await page.close();
+                }
+            }
+        }
+        finally {
+            await context.close();
+            await browser.close();
+        }
+        return RouteInventorySchema.parse({
+            scannedAt: new Date().toISOString(),
+            baseUrl,
+            routes,
+            pagesSkipped: budgetExceeded ? queue.length : 0,
+            budgetExceeded,
+        });
+    }
+}

package/dist/tools/repo-scanner.d.ts

@@ -0,0 +1,3 @@
+import { type RepoAnalysis } from '../schemas/repo-analysis.schema.js';
+export declare function scanRepo(repoPath: string): Promise<RepoAnalysis>;
+//# sourceMappingURL=repo-scanner.d.ts.map

package/dist/tools/repo-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-scanner.d.ts","sourceRoot":"","sources":["../../src/tools/repo-scanner.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAiC3F,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA4HtE"}