@qulib/core 0.3.1 → 0.4.0

package/dist/schemas/repo-analysis.schema.d.ts

@@ -1,4 +1,25 @@
 import { z } from 'zod';
+export declare const DetectedFrameworkPrimarySchema: z.ZodEnum<["nextjs-app-router", "nextjs-pages-router", "express", "remix", "nuxt", "sveltekit", "astro", "vite", "unknown"]>;
+export declare const FrameworkDetectionConfidenceSchema: z.ZodEnum<["high", "medium", "low"]>;
+export declare const TestFrameworkDetectedSchema: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "jest", "vitest", "other"]>;
+export declare const FrameworkDetectionSchema: z.ZodObject<{
+    primary: z.ZodEnum<["nextjs-app-router", "nextjs-pages-router", "express", "remix", "nuxt", "sveltekit", "astro", "vite", "unknown"]>;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    evidence: z.ZodArray<z.ZodString, "many">;
+    testFrameworks: z.ZodArray<z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "jest", "vitest", "other"]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    confidence: "high" | "medium" | "low";
+    evidence: string[];
+    primary: "unknown" | "nextjs-app-router" | "nextjs-pages-router" | "express" | "remix" | "nuxt" | "sveltekit" | "astro" | "vite";
+    testFrameworks: ("playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other")[];
+}, {
+    confidence: "high" | "medium" | "low";
+    evidence: string[];
+    primary: "unknown" | "nextjs-app-router" | "nextjs-pages-router" | "express" | "remix" | "nuxt" | "sveltekit" | "astro" | "vite";
+    testFrameworks: ("playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other")[];
+}>;
+export type DetectedFrameworkPrimary = z.infer<typeof DetectedFrameworkPrimarySchema>;
+export type FrameworkDetectionResult = z.infer<typeof FrameworkDetectionSchema>;
 export declare const RepoRouteSchema: z.ZodObject<{
     path: z.ZodString;
     file: z.ZodString;
@@ -111,6 +132,77 @@ export declare const RepoAnalysisSchema: z.ZodObject<{
         fixturesFolder?: string | undefined;
         supportFolder?: string | undefined;
     }>;
+    framework: z.ZodOptional<z.ZodObject<{
+        primary: z.ZodEnum<["nextjs-app-router", "nextjs-pages-router", "express", "remix", "nuxt", "sveltekit", "astro", "vite", "unknown"]>;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+        evidence: z.ZodArray<z.ZodString, "many">;
+        testFrameworks: z.ZodArray<z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "jest", "vitest", "other"]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        confidence: "high" | "medium" | "low";
+        evidence: string[];
+        primary: "unknown" | "nextjs-app-router" | "nextjs-pages-router" | "express" | "remix" | "nuxt" | "sveltekit" | "astro" | "vite";
+        testFrameworks: ("playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other")[];
+    }, {
+        confidence: "high" | "medium" | "low";
+        evidence: string[];
+        primary: "unknown" | "nextjs-app-router" | "nextjs-pages-router" | "express" | "remix" | "nuxt" | "sveltekit" | "astro" | "vite";
+        testFrameworks: ("playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other")[];
+    }>>;
+    automationMaturity: z.ZodOptional<z.ZodObject<{
+        computedAt: z.ZodString;
+        repoPath: z.ZodString;
+        overallScore: z.ZodNumber;
+        level: z.ZodNumber;
+        label: z.ZodString;
+        dimensions: z.ZodArray<z.ZodObject<{
+            dimension: z.ZodEnum<["test-coverage-breadth", "framework-adoption", "test-id-hygiene", "ci-integration", "auth-test-coverage", "component-test-ratio"]>;
+            score: z.ZodNumber;
+            weight: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodString, "many">;
+            recommendations: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            recommendations: string[];
+            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio";
+            score: number;
+            weight: number;
+            evidence: string[];
+        }, {
+            recommendations: string[];
+            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio";
+            score: number;
+            weight: number;
+            evidence: string[];
+        }>, "many">;
+        topRecommendations: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        level: number;
+        computedAt: string;
+        repoPath: string;
+        overallScore: number;
+        dimensions: {
+            recommendations: string[];
+            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio";
+            score: number;
+            weight: number;
+            evidence: string[];
+        }[];
+        topRecommendations: string[];
+    }, {
+        label: string;
+        level: number;
+        computedAt: string;
+        repoPath: string;
+        overallScore: number;
+        dimensions: {
+            recommendations: string[];
+            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio";
+            score: number;
+            weight: number;
+            evidence: string[];
+        }[];
+        topRecommendations: string[];
+    }>>;
 }, "strip", z.ZodTypeAny, {
     scannedAt: string;
     routes: {
@@ -135,6 +227,27 @@ export declare const RepoAnalysisSchema: z.ZodObject<{
         fixturesFolder?: string | undefined;
         supportFolder?: string | undefined;
     };
+    framework?: {
+        confidence: "high" | "medium" | "low";
+        evidence: string[];
+        primary: "unknown" | "nextjs-app-router" | "nextjs-pages-router" | "express" | "remix" | "nuxt" | "sveltekit" | "astro" | "vite";
+        testFrameworks: ("playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other")[];
+    } | undefined;
+    automationMaturity?: {
+        label: string;
+        level: number;
+        computedAt: string;
+        repoPath: string;
+        overallScore: number;
+        dimensions: {
+            recommendations: string[];
+            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio";
+            score: number;
+            weight: number;
+            evidence: string[];
+        }[];
+        topRecommendations: string[];
+    } | undefined;
 }, {
     scannedAt: string;
     routes: {
@@ -159,6 +272,27 @@ export declare const RepoAnalysisSchema: z.ZodObject<{
         fixturesFolder?: string | undefined;
         supportFolder?: string | undefined;
     };
+    framework?: {
+        confidence: "high" | "medium" | "low";
+        evidence: string[];
+        primary: "unknown" | "nextjs-app-router" | "nextjs-pages-router" | "express" | "remix" | "nuxt" | "sveltekit" | "astro" | "vite";
+        testFrameworks: ("playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other")[];
+    } | undefined;
+    automationMaturity?: {
+        label: string;
+        level: number;
+        computedAt: string;
+        repoPath: string;
+        overallScore: number;
+        dimensions: {
+            recommendations: string[];
+            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio";
+            score: number;
+            weight: number;
+            evidence: string[];
+        }[];
+        topRecommendations: string[];
+    } | undefined;
 }>;
 export type RepoAnalysis = z.infer<typeof RepoAnalysisSchema>;
 export type CypressStructure = z.infer<typeof CypressStructureSchema>;

package/dist/schemas/repo-analysis.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repo-analysis.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/repo-analysis.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;EASjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"repo-analysis.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/repo-analysis.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,8BAA8B,8HAUzC,CAAC;AAEH,eAAO,MAAM,kCAAkC,sCAAoC,CAAC;AAEpF,eAAO,MAAM,2BAA2B,0FAOtC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;EAKnC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;EASjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/schemas/repo-analysis.schema.js

@@ -1,4 +1,31 @@
 import { z } from 'zod';
+import { AutomationMaturitySchema } from './automation-maturity.schema.js';
+export const DetectedFrameworkPrimarySchema = z.enum([
+    'nextjs-app-router',
+    'nextjs-pages-router',
+    'express',
+    'remix',
+    'nuxt',
+    'sveltekit',
+    'astro',
+    'vite',
+    'unknown',
+]);
+export const FrameworkDetectionConfidenceSchema = z.enum(['high', 'medium', 'low']);
+export const TestFrameworkDetectedSchema = z.enum([
+    'playwright',
+    'cypress-e2e',
+    'cypress-component',
+    'jest',
+    'vitest',
+    'other',
+]);
+export const FrameworkDetectionSchema = z.object({
+    primary: DetectedFrameworkPrimarySchema,
+    confidence: FrameworkDetectionConfidenceSchema,
+    evidence: z.array(z.string()),
+    testFrameworks: z.array(TestFrameworkDetectedSchema),
+});
 export const RepoRouteSchema = z.object({
     path: z.string(),
     file: z.string(),
@@ -26,4 +53,6 @@ export const RepoAnalysisSchema = z.object({
     testFiles: z.array(TestFileSchema),
     missingTestIds: z.array(z.string()),
     cypressStructure: CypressStructureSchema,
+    framework: FrameworkDetectionSchema.optional(),
+    automationMaturity: AutomationMaturitySchema.optional(),
 });

package/dist/telemetry/emit.d.ts

@@ -0,0 +1,3 @@
+import type { TelemetryEvent, TelemetryEventKind, TelemetrySink } from './telemetry.interface.js';
+export declare function emitTelemetry(sink: TelemetrySink | undefined, kind: TelemetryEventKind, sessionId: string, metadata: TelemetryEvent['metadata'], durationMs?: number): void;
+//# sourceMappingURL=emit.d.ts.map

package/dist/telemetry/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/telemetry/emit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAElG,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,GAAG,SAAS,EAC/B,IAAI,EAAE,kBAAkB,EACxB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,EACpC,UAAU,CAAC,EAAE,MAAM,GAClB,IAAI,CASN"}

package/dist/telemetry/emit.js

@@ -0,0 +1,11 @@
+export function emitTelemetry(sink, kind, sessionId, metadata, durationMs) {
+    if (!sink)
+        return;
+    sink.emit({
+        kind,
+        timestamp: new Date().toISOString(),
+        sessionId,
+        metadata,
+        ...(durationMs !== undefined && { durationMs }),
+    });
+}

package/dist/telemetry/telemetry.interface.d.ts

@@ -0,0 +1,13 @@
+export type TelemetryEventKind = 'scan.started' | 'scan.completed' | 'scan.blocked' | 'phase.observe.started' | 'phase.observe.completed' | 'phase.think.started' | 'phase.think.completed' | 'phase.act.started' | 'phase.act.completed' | 'llm.call.started' | 'llm.call.completed' | 'llm.call.failed' | 'gap.detected' | 'auth.detected' | 'repo.scanned';
+export interface TelemetryEvent {
+    kind: TelemetryEventKind;
+    timestamp: string;
+    sessionId: string;
+    durationMs?: number;
+    metadata: Record<string, string | number | boolean | null>;
+}
+export interface TelemetrySink {
+    emit(event: TelemetryEvent): void;
+}
+export declare const NoopTelemetrySink: TelemetrySink;
+//# sourceMappingURL=telemetry.interface.d.ts.map

package/dist/telemetry/telemetry.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.interface.d.ts","sourceRoot":"","sources":["../../src/telemetry/telemetry.interface.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC1B,cAAc,GACd,gBAAgB,GAChB,cAAc,GACd,uBAAuB,GACvB,yBAAyB,GACzB,qBAAqB,GACrB,uBAAuB,GACvB,mBAAmB,GACnB,qBAAqB,GACrB,kBAAkB,GAClB,oBAAoB,GACpB,iBAAiB,GACjB,cAAc,GACd,eAAe,GACf,cAAc,CAAC;AAEnB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;CACnC;AAED,eAAO,MAAM,iBAAiB,EAAE,aAE/B,CAAC"}

package/dist/telemetry/telemetry.interface.js

@@ -0,0 +1,3 @@
+export const NoopTelemetrySink = {
+    emit: () => { },
+};

package/dist/tools/automation-maturity.d.ts

@@ -0,0 +1,4 @@
+import type { RepoAnalysis } from '../schemas/repo-analysis.schema.js';
+import type { AutomationMaturity } from '../schemas/automation-maturity.schema.js';
+export declare function computeAutomationMaturity(repo: RepoAnalysis): AutomationMaturity;
+//# sourceMappingURL=automation-maturity.d.ts.map

package/dist/tools/automation-maturity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation-maturity.d.ts","sourceRoot":"","sources":["../../src/tools/automation-maturity.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAA+B,MAAM,0CAA0C,CAAC;AAiDhH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,YAAY,GAAG,kBAAkB,CA6HhF"}

package/dist/tools/automation-maturity.js

@@ -0,0 +1,163 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { AutomationMaturitySchema } from '../schemas/automation-maturity.schema.js';
+/**
+ * Dimension weights (sum = 1). Breadth + harness adoption dominate: shipping risk is mostly
+ * untested routes and missing Playwright/Cypress-level coverage.
+ */
+const W_TEST_BREADTH = 0.28;
+const W_FRAMEWORK = 0.22;
+const W_TEST_ID = 0.18;
+const W_CI = 0.14;
+const W_AUTH_TESTS = 0.1;
+const W_COMPONENT_RATIO = 0.08;
+function hasCiAtRoot(repoPath) {
+    const ev = [];
+    const gh = join(repoPath, '.github', 'workflows');
+    if (existsSync(gh) && statSync(gh).isDirectory()) {
+        try {
+            const files = readdirSync(gh).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+            if (files.length > 0) {
+                ev.push(`.github/workflows (${files.length} workflow file(s))`);
+                return { ok: true, evidence: ev };
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    if (existsSync(join(repoPath, '.circleci'))) {
+        ev.push('.circleci/ present');
+        return { ok: true, evidence: ev };
+    }
+    for (const f of ['.gitlab-ci.yml', 'Jenkinsfile']) {
+        if (existsSync(join(repoPath, f))) {
+            ev.push(`${f} present`);
+            return { ok: true, evidence: ev };
+        }
+    }
+    return { ok: false, evidence: ['No GitHub Actions, CircleCI, GitLab CI, or Jenkinsfile detected at repo root'] };
+}
+function scoreLevel(overall) {
+    if (overall < 20)
+        return { level: 1, label: 'L1 — nascent automation' };
+    if (overall < 40)
+        return { level: 2, label: 'L2 — emerging coverage' };
+    if (overall < 60)
+        return { level: 3, label: 'L3 — building maturity' };
+    if (overall < 80)
+        return { level: 4, label: 'L4 — strong automation' };
+    return { level: 5, label: 'L5 — advanced QA automation' };
+}
+export function computeAutomationMaturity(repo) {
+    const routePaths = [...new Set(repo.routes.map((r) => r.path))];
+    let coveredRoutes = 0;
+    for (const p of routePaths) {
+        const covered = repo.testFiles.some((tf) => tf.coveredPaths.some((c) => p === c || (c !== '/' && p.startsWith(c))));
+        if (covered)
+            coveredRoutes++;
+    }
+    const breadthScore = routePaths.length === 0 ? 100 : Math.round((100 * coveredRoutes) / routePaths.length);
+    const breadthDim = {
+        dimension: 'test-coverage-breadth',
+        score: breadthScore,
+        weight: W_TEST_BREADTH,
+        evidence: routePaths.length === 0
+            ? ['No static routes inferred from repo layout']
+            : [
+                `${coveredRoutes}/${routePaths.length} inferred routes appear in at least one test coveredPaths`,
+            ],
+        recommendations: breadthScore >= 80
+            ? []
+            : ['Add route-level smoke tests that assert critical paths referenced in production URLs.'],
+    };
+    const types = new Set(repo.testFiles.map((t) => t.type));
+    let frameworkScore = 0;
+    const fwEvidence = [`Test runners seen: ${[...types].join(', ') || 'none'}`];
+    if (types.has('playwright') || types.has('cypress-e2e') || types.has('cypress-component')) {
+        frameworkScore = 100;
+        fwEvidence.push('Playwright or Cypress present — good browser harness signal.');
+    }
+    else if (types.has('jest') || types.has('vitest')) {
+        frameworkScore = 55;
+        fwEvidence.push('Jest/Vitest only — add Playwright or Cypress for deployment-facing checks.');
+    }
+    else if (repo.testFiles.length > 0) {
+        frameworkScore = 30;
+        fwEvidence.push('Tests exist but no recognized browser harness in scanned files.');
+    }
+    else {
+        frameworkScore = 0;
+        fwEvidence.push('No test files matched qulib scan globs.');
+    }
+    const frameworkDim = {
+        dimension: 'framework-adoption',
+        score: frameworkScore,
+        weight: W_FRAMEWORK,
+        evidence: fwEvidence,
+        recommendations: frameworkScore >= 80 ? [] : ['Standardize on Playwright or Cypress for E2E against deployed URLs.'],
+    };
+    const hygienePenalty = Math.min(100, repo.missingTestIds.length * 6);
+    const hygieneScore = Math.max(0, 100 - hygienePenalty);
+    const hygieneDim = {
+        dimension: 'test-id-hygiene',
+        score: hygieneScore,
+        weight: W_TEST_ID,
+        evidence: [
+            `${repo.missingTestIds.length} TSX file(s) with interactive markup but no data-testid (heuristic scan).`,
+        ],
+        recommendations: hygieneScore >= 85 ? [] : ['Add stable data-testid (or role-based selectors) on interactive components used in tests.'],
+    };
+    const ci = hasCiAtRoot(repo.repoPath);
+    const ciDim = {
+        dimension: 'ci-integration',
+        score: ci.ok ? 100 : 0,
+        weight: W_CI,
+        evidence: ci.evidence,
+        recommendations: ci.ok ? [] : ['Add a CI workflow that runs unit/E2E tests on every PR.'],
+    };
+    const authRe = /\/(login|auth|signin)(\/|$)/i;
+    const authCovered = repo.testFiles.some((tf) => tf.coveredPaths.some((c) => authRe.test(c)));
+    const authScore = authCovered ? 90 : 25;
+    const authDim = {
+        dimension: 'auth-test-coverage',
+        score: authScore,
+        weight: W_AUTH_TESTS,
+        evidence: authCovered
+            ? ['At least one test references /login, /auth, or /signin in coveredPaths.']
+            : ['No obvious auth-route coverage in extracted test path strings.'],
+        recommendations: authCovered ? [] : ['Add focused tests for sign-in and post-auth landing behavior.'],
+    };
+    const cypressE2e = repo.testFiles.filter((t) => t.type === 'cypress-e2e').length;
+    const cypressComp = repo.testFiles.filter((t) => t.type === 'cypress-component').length;
+    const cypressTotal = cypressE2e + cypressComp;
+    const compRatioScore = cypressTotal === 0 ? 50 : Math.round((100 * cypressComp) / cypressTotal);
+    const compDim = {
+        dimension: 'component-test-ratio',
+        score: compRatioScore,
+        weight: W_COMPONENT_RATIO,
+        evidence: [
+            `Cypress e2e files (matched): ${cypressE2e}, component: ${cypressComp}.`,
+        ],
+        recommendations: cypressComp === 0 || cypressTotal === 0
+            ? []
+            : ['Balance component vs E2E Cypress tests so critical flows stay fast in CI.'],
+    };
+    const dimensions = [breadthDim, frameworkDim, hygieneDim, ciDim, authDim, compDim];
+    const overallScore = Math.round(dimensions.reduce((s, d) => s + d.score * d.weight, 0));
+    const { level, label } = scoreLevel(overallScore);
+    const topRecommendations = [...dimensions]
+        .sort((a, b) => a.score - b.score)
+        .flatMap((d) => d.recommendations)
+        .filter(Boolean)
+        .slice(0, 8);
+    return AutomationMaturitySchema.parse({
+        computedAt: new Date().toISOString(),
+        repoPath: repo.repoPath,
+        overallScore,
+        level,
+        label,
+        dimensions,
+        topRecommendations,
+    });
+}

package/dist/tools/framework-detector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module framework-detector
+ * @packageBoundary @qulib/core (candidate: @qulib/analyzer)
+ *
+ * Framework detection runs during the observe phase as part of repo scanning.
+ * It is a pure static analysis operation with no browser or LLM dependency.
+ * Move this to @qulib/analyzer when that package is created.
+ *
+ * // TODO(@qulib/analyzer): When @qulib/analyzer is extracted, this module should move there.
+ * // It is currently embedded in @qulib/core because repo scanning is part of the observe phase.
+ * // The package boundary decision: core = runtime QA analysis, analyzer = static repo intelligence.
+ */
+import { type FrameworkDetectionResult } from '../schemas/repo-analysis.schema.js';
+export declare function detectFramework(repoPath: string): Promise<FrameworkDetectionResult>;
+//# sourceMappingURL=framework-detector.d.ts.map

package/dist/tools/framework-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-detector.d.ts","sourceRoot":"","sources":["../../src/tools/framework-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,OAAO,EAA4B,KAAK,wBAAwB,EAAE,MAAM,oCAAoC,CAAC;AAuB7G,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC,CA4GzF"}

package/dist/tools/framework-detector.js

@@ -0,0 +1,153 @@
+/**
+ * @module framework-detector
+ * @packageBoundary @qulib/core (candidate: @qulib/analyzer)
+ *
+ * Framework detection runs during the observe phase as part of repo scanning.
+ * It is a pure static analysis operation with no browser or LLM dependency.
+ * Move this to @qulib/analyzer when that package is created.
+ *
+ * // TODO(@qulib/analyzer): When @qulib/analyzer is extracted, this module should move there.
+ * // It is currently embedded in @qulib/core because repo scanning is part of the observe phase.
+ * // The package boundary decision: core = runtime QA analysis, analyzer = static repo intelligence.
+ */
+import { access, readFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import { FrameworkDetectionSchema } from '../schemas/repo-analysis.schema.js';
+async function fileExists(repoPath, rel) {
+    try {
+        await access(join(repoPath, rel), constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function depNames(pkg) {
+    return new Set([
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+    ]);
+}
+export async function detectFramework(repoPath) {
+    const evidence = [];
+    const testFrameworks = new Set();
+    let pkg = {};
+    try {
+        const raw = await readFile(join(repoPath, 'package.json'), 'utf8');
+        pkg = JSON.parse(raw);
+        evidence.push('read package.json');
+    }
+    catch {
+        evidence.push('package.json missing or unreadable');
+    }
+    const deps = depNames(pkg);
+    const has = (n) => deps.has(n);
+    if (has('@playwright/test') || has('playwright')) {
+        testFrameworks.add('playwright');
+        evidence.push('dependency: @playwright/test or playwright');
+    }
+    if (has('cypress')) {
+        testFrameworks.add('cypress-e2e');
+        evidence.push('dependency: cypress');
+    }
+    if (has('jest')) {
+        testFrameworks.add('jest');
+        evidence.push('dependency: jest');
+    }
+    if (has('vitest')) {
+        testFrameworks.add('vitest');
+        evidence.push('dependency: vitest');
+    }
+    if (testFrameworks.size === 0) {
+        testFrameworks.add('other');
+    }
+    const nextCfg = (await fileExists(repoPath, 'next.config.js')) ||
+        (await fileExists(repoPath, 'next.config.mjs')) ||
+        (await fileExists(repoPath, 'next.config.ts'));
+    const nuxtCfg = await fileExists(repoPath, 'nuxt.config.ts');
+    const svelteCfg = await fileExists(repoPath, 'svelte.config.js');
+    const astroCfg = await fileExists(repoPath, 'astro.config.mjs');
+    const remixCfg = await fileExists(repoPath, 'remix.config.js');
+    const viteCfg = await fileExists(repoPath, 'vite.config.ts');
+    if (nextCfg)
+        evidence.push('found next.config.*');
+    if (nuxtCfg)
+        evidence.push('found nuxt.config.ts');
+    if (svelteCfg)
+        evidence.push('found svelte.config.js');
+    if (astroCfg)
+        evidence.push('found astro.config.mjs');
+    if (remixCfg)
+        evidence.push('found remix.config.js');
+    if (viteCfg)
+        evidence.push('found vite.config.ts');
+    const hasAppDir = await fileExists(repoPath, 'app');
+    const hasPagesDir = await fileExists(repoPath, 'pages');
+    if (has('next') && hasAppDir)
+        evidence.push('Next.js app/ directory present');
+    if (has('next') && hasPagesDir)
+        evidence.push('Next.js pages/ directory present');
+    if (has('@remix-run/react') || has('@remix-run/node'))
+        evidence.push('Remix packages in package.json');
+    if (has('nuxt') || has('nuxt3'))
+        evidence.push('Nuxt in package.json');
+    if (has('@sveltejs/kit'))
+        evidence.push('@sveltejs/kit in package.json');
+    if (has('astro'))
+        evidence.push('astro in package.json');
+    if (has('vite') && !has('next'))
+        evidence.push('vite in package.json (non-Next)');
+    let primary = 'unknown';
+    let confidence = 'low';
+    if (has('next')) {
+        if (hasAppDir && (await fileExists(repoPath, join('app', 'layout.tsx')))) {
+            primary = 'nextjs-app-router';
+            confidence = nextCfg || hasAppDir ? 'high' : 'medium';
+        }
+        else if (hasPagesDir) {
+            primary = 'nextjs-pages-router';
+            confidence = nextCfg || hasPagesDir ? 'high' : 'medium';
+        }
+        else {
+            primary = 'nextjs-app-router';
+            confidence = 'medium';
+            evidence.push('next detected without clear app/ vs pages/ layout');
+        }
+    }
+    else if (has('@remix-run/react') || remixCfg) {
+        primary = 'remix';
+        confidence = remixCfg ? 'high' : 'medium';
+    }
+    else if (has('nuxt') || nuxtCfg) {
+        primary = 'nuxt';
+        confidence = nuxtCfg ? 'high' : 'medium';
+    }
+    else if (has('@sveltejs/kit') || svelteCfg) {
+        primary = 'sveltekit';
+        confidence = svelteCfg ? 'high' : 'medium';
+    }
+    else if (has('astro') || astroCfg) {
+        primary = 'astro';
+        confidence = astroCfg ? 'high' : 'medium';
+    }
+    else if (viteCfg && !has('next')) {
+        primary = 'vite';
+        confidence = 'medium';
+    }
+    else if (has('express')) {
+        primary = 'express';
+        confidence = 'medium';
+        evidence.push('express listed in dependencies');
+    }
+    else {
+        /* keep unknown */
+    }
+    const raw = {
+        primary,
+        confidence,
+        evidence,
+        testFrameworks: [...testFrameworks],
+    };
+    return FrameworkDetectionSchema.parse(raw);
+}

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

@@ -2,7 +2,7 @@ import { type GapAnalysis, type Gap } 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 computeQualityScoreFromGaps(gaps: Gap[]): number;
+export declare function computeQualityScoreFromGaps(gaps: Gap[], scoringWeights?: HarnessConfig['scoringWeights']): number;
 export declare function computeCoverageScore(routes: RouteInventory): number | null;
 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

@@ -1 +1 @@
-{"version":3,"file":"gap-engine.d.ts","sourceRoot":"","sources":["../../src/tools/gap-engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,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,2BAA2B,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,CAY/D;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CAa1E;AAED,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,CAqGnD"}
+{"version":3,"file":"gap-engine.d.ts","sourceRoot":"","sources":["../../src/tools/gap-engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,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;AAQjE,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,GAAG,EAAE,EACX,cAAc,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAC/C,MAAM,CAkBR;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CAa1E;AAED,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,CAqGnD"}

package/dist/tools/gap-engine.js

@@ -1,6 +1,10 @@
 import { randomUUID } from 'node:crypto';
 import { GapSchema } from '../schemas/gap-analysis.schema.js';
-export function computeQualityScoreFromGaps(gaps) {
+// TODO: Add category-specific weight overrides (e.g., auth-surface gaps should cost more than untested-route gaps by default).
+// Requires a 2D weight matrix: { [severity]: { [category]: number } }.
+// Deferred until there is empirical data from real scan runs to calibrate.
+const DEFAULT_SCORING_WEIGHTS = { critical: 25, high: 20, medium: 8, low: 3 };
+export function computeQualityScoreFromGaps(gaps, scoringWeights) {
     let critical = 0;
     let high = 0;
     let medium = 0;
@@ -15,7 +19,13 @@ export function computeQualityScoreFromGaps(gaps) {
         else
             low++;
     }
-    return Math.max(0, 100 - critical * 25 - high * 20 - medium * 8 - low * 3);
+    const w = {
+        critical: scoringWeights?.critical ?? DEFAULT_SCORING_WEIGHTS.critical,
+        high: scoringWeights?.high ?? DEFAULT_SCORING_WEIGHTS.high,
+        medium: scoringWeights?.medium ?? DEFAULT_SCORING_WEIGHTS.medium,
+        low: scoringWeights?.low ?? DEFAULT_SCORING_WEIGHTS.low,
+    };
+    return Math.max(0, 100 - critical * w.critical - high * w.high - medium * w.medium - low * w.low);
 }
 export function computeCoverageScore(routes) {
     const scanned = routes.routes.length;
@@ -104,7 +114,7 @@ export function analyzeGaps(routes, repo, mode, config) {
             });
         }
     }
-    const releaseConfidence = computeQualityScoreFromGaps(gaps);
+    const releaseConfidence = computeQualityScoreFromGaps(gaps, config.scoringWeights);
     const pagesScanned = routes.routes.length;
     let coverageWarning;
     if (routes.budgetExceeded) {