@qulib/core 0.2.2 → 0.3.0

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

@@ -2,21 +2,27 @@ import { z } from 'zod';
 export declare const GapSchema: z.ZodObject<{
     id: z.ZodString;
     path: z.ZodString;
-    severity: z.ZodEnum<["high", "medium", "low"]>;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
     reason: z.ZodString;
-    category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link"]>;
+    category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage"]>;
+    description: z.ZodOptional<z.ZodString>;
+    recommendation: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     id: string;
-    severity: "high" | "medium" | "low";
+    severity: "high" | "medium" | "low" | "critical";
     reason: string;
-    category: "untested-route" | "a11y" | "console-error" | "broken-link";
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+    recommendation?: string | undefined;
+    description?: string | undefined;
 }, {
     path: string;
     id: string;
-    severity: "high" | "medium" | "low";
+    severity: "high" | "medium" | "low" | "critical";
     reason: string;
-    category: "untested-route" | "a11y" | "console-error" | "broken-link";
+    category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+    recommendation?: string | undefined;
+    description?: string | undefined;
 }>;
 export declare const FrameworkRecommendationSchema: z.ZodObject<{
     adapter: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "api", "accessibility"]>;
@@ -37,13 +43,13 @@ export declare const TestStepSchema: z.ZodObject<{
     value: z.ZodOptional<z.ZodString>;
     description: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
     description: string;
+    action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
     value?: string | undefined;
     target?: string | undefined;
 }, {
-    action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
     description: string;
+    action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
     value?: string | undefined;
     target?: string | undefined;
 }>;
@@ -59,13 +65,13 @@ export declare const NeutralScenarioSchema: z.ZodObject<{
         value: z.ZodOptional<z.ZodString>;
         description: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         description: string;
+        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         value?: string | undefined;
         target?: string | undefined;
     }, {
-        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         description: string;
+        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         value?: string | undefined;
         target?: string | undefined;
     }>, "many">;
@@ -90,8 +96,8 @@ export declare const NeutralScenarioSchema: z.ZodObject<{
     title: string;
     targetPath: string;
     steps: {
-        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         description: string;
+        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         value?: string | undefined;
         target?: string | undefined;
     }[];
@@ -109,8 +115,8 @@ export declare const NeutralScenarioSchema: z.ZodObject<{
     title: string;
     targetPath: string;
     steps: {
-        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         description: string;
+        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
         value?: string | undefined;
         target?: string | undefined;
     }[];
@@ -148,28 +154,34 @@ export declare const GeneratedTestSchema: z.ZodObject<{
 export declare const GapAnalysisSchema: z.ZodObject<{
     analyzedAt: z.ZodString;
     mode: z.ZodEnum<["url-only", "url-repo", "auth-required"]>;
-    releaseConfidence: z.ZodNumber;
+    releaseConfidence: z.ZodUnion<[z.ZodNumber, z.ZodNull]>;
     coveragePagesScanned: z.ZodNumber;
     coverageBudgetExceeded: z.ZodBoolean;
     coverageWarning: z.ZodOptional<z.ZodEnum<["budget-exceeded", "low-coverage", "navigation-failures", "auth-required"]>>;
     gaps: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         path: z.ZodString;
-        severity: z.ZodEnum<["high", "medium", "low"]>;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
         reason: z.ZodString;
-        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link"]>;
+        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link", "auth-surface", "coverage"]>;
+        description: z.ZodOptional<z.ZodString>;
+        recommendation: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         path: string;
         id: string;
-        severity: "high" | "medium" | "low";
+        severity: "high" | "medium" | "low" | "critical";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+        recommendation?: string | undefined;
+        description?: string | undefined;
     }, {
         path: string;
         id: string;
-        severity: "high" | "medium" | "low";
+        severity: "high" | "medium" | "low" | "critical";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+        recommendation?: string | undefined;
+        description?: string | undefined;
     }>, "many">;
     scenarios: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -183,13 +195,13 @@ export declare const GapAnalysisSchema: z.ZodObject<{
             value: z.ZodOptional<z.ZodString>;
             description: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             description: string;
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             value?: string | undefined;
             target?: string | undefined;
         }, {
-            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             description: string;
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             value?: string | undefined;
             target?: string | undefined;
         }>, "many">;
@@ -214,8 +226,8 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         title: string;
         targetPath: string;
         steps: {
-            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             description: string;
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             value?: string | undefined;
             target?: string | undefined;
         }[];
@@ -233,8 +245,8 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         title: string;
         targetPath: string;
         steps: {
-            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             description: string;
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             value?: string | undefined;
             target?: string | undefined;
         }[];
@@ -269,18 +281,173 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         filename: string;
         outputPath: string;
     }>, "many">;
+    costIntelligence: z.ZodOptional<z.ZodObject<{
+        maxOutputTokensPerLlmCall: z.ZodNumber;
+        budgetRole: z.ZodLiteral<"max-output-tokens-per-llm-call">;
+        records: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            estimatedCostUsd: z.ZodOptional<z.ZodNumber>;
+            operationType: z.ZodEnum<["scenario-generation"]>;
+            timestamp: z.ZodString;
+            promptHash: z.ZodOptional<z.ZodString>;
+            resultHash: z.ZodOptional<z.ZodString>;
+            dataQuality: z.ZodEnum<["actual", "estimated", "mixed", "none"]>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            operationType: "scenario-generation";
+            timestamp: string;
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            estimatedCostUsd?: number | undefined;
+            promptHash?: string | undefined;
+            resultHash?: string | undefined;
+            notes?: string | undefined;
+        }, {
+            provider: string;
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            operationType: "scenario-generation";
+            timestamp: string;
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            estimatedCostUsd?: number | undefined;
+            promptHash?: string | undefined;
+            resultHash?: string | undefined;
+            notes?: string | undefined;
+        }>, "many">;
+        budgetWarnings: z.ZodArray<z.ZodString, "many">;
+        usageSummary: z.ZodObject<{
+            totalInputTokens: z.ZodNumber;
+            totalOutputTokens: z.ZodNumber;
+            dataQuality: z.ZodEnum<["actual", "estimated", "mixed", "none"]>;
+        }, "strip", z.ZodTypeAny, {
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            totalInputTokens: number;
+            totalOutputTokens: number;
+        }, {
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            totalInputTokens: number;
+            totalOutputTokens: number;
+        }>;
+        repeatedOperations: z.ZodArray<z.ZodObject<{
+            promptHash: z.ZodString;
+            count: z.ZodNumber;
+            recommendation: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            recommendation: string;
+            promptHash: string;
+            count: number;
+        }, {
+            recommendation: string;
+            promptHash: string;
+            count: number;
+        }>, "many">;
+        deterministicMaturity: z.ZodObject<{
+            level: z.ZodNumber;
+            label: z.ZodString;
+            rationale: z.ZodString;
+            ceilingNote: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            level: number;
+            rationale: string;
+            ceilingNote?: string | undefined;
+        }, {
+            label: string;
+            level: number;
+            rationale: string;
+            ceilingNote?: string | undefined;
+        }>;
+        conversionRecommendations: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        maxOutputTokensPerLlmCall: number;
+        budgetRole: "max-output-tokens-per-llm-call";
+        records: {
+            provider: string;
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            operationType: "scenario-generation";
+            timestamp: string;
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            estimatedCostUsd?: number | undefined;
+            promptHash?: string | undefined;
+            resultHash?: string | undefined;
+            notes?: string | undefined;
+        }[];
+        budgetWarnings: string[];
+        usageSummary: {
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            totalInputTokens: number;
+            totalOutputTokens: number;
+        };
+        repeatedOperations: {
+            recommendation: string;
+            promptHash: string;
+            count: number;
+        }[];
+        deterministicMaturity: {
+            label: string;
+            level: number;
+            rationale: string;
+            ceilingNote?: string | undefined;
+        };
+        conversionRecommendations: string[];
+    }, {
+        maxOutputTokensPerLlmCall: number;
+        budgetRole: "max-output-tokens-per-llm-call";
+        records: {
+            provider: string;
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            operationType: "scenario-generation";
+            timestamp: string;
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            estimatedCostUsd?: number | undefined;
+            promptHash?: string | undefined;
+            resultHash?: string | undefined;
+            notes?: string | undefined;
+        }[];
+        budgetWarnings: string[];
+        usageSummary: {
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            totalInputTokens: number;
+            totalOutputTokens: number;
+        };
+        repeatedOperations: {
+            recommendation: string;
+            promptHash: string;
+            count: number;
+        }[];
+        deterministicMaturity: {
+            label: string;
+            level: number;
+            rationale: string;
+            ceilingNote?: string | undefined;
+        };
+        conversionRecommendations: string[];
+    }>>;
 }, "strip", z.ZodTypeAny, {
     analyzedAt: string;
     mode: "url-only" | "url-repo" | "auth-required";
-    releaseConfidence: number;
+    releaseConfidence: number | null;
     coveragePagesScanned: number;
     coverageBudgetExceeded: boolean;
     gaps: {
         path: string;
         id: string;
-        severity: "high" | "medium" | "low";
+        severity: "high" | "medium" | "low" | "critical";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+        recommendation?: string | undefined;
+        description?: string | undefined;
     }[];
     scenarios: {
         id: string;
@@ -288,8 +455,8 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         title: string;
         targetPath: string;
         steps: {
-            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             description: string;
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             value?: string | undefined;
             target?: string | undefined;
         }[];
@@ -311,18 +478,55 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         outputPath: string;
     }[];
     coverageWarning?: "auth-required" | "budget-exceeded" | "low-coverage" | "navigation-failures" | undefined;
+    costIntelligence?: {
+        maxOutputTokensPerLlmCall: number;
+        budgetRole: "max-output-tokens-per-llm-call";
+        records: {
+            provider: string;
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            operationType: "scenario-generation";
+            timestamp: string;
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            estimatedCostUsd?: number | undefined;
+            promptHash?: string | undefined;
+            resultHash?: string | undefined;
+            notes?: string | undefined;
+        }[];
+        budgetWarnings: string[];
+        usageSummary: {
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            totalInputTokens: number;
+            totalOutputTokens: number;
+        };
+        repeatedOperations: {
+            recommendation: string;
+            promptHash: string;
+            count: number;
+        }[];
+        deterministicMaturity: {
+            label: string;
+            level: number;
+            rationale: string;
+            ceilingNote?: string | undefined;
+        };
+        conversionRecommendations: string[];
+    } | undefined;
 }, {
     analyzedAt: string;
     mode: "url-only" | "url-repo" | "auth-required";
-    releaseConfidence: number;
+    releaseConfidence: number | null;
     coveragePagesScanned: number;
     coverageBudgetExceeded: boolean;
     gaps: {
         path: string;
         id: string;
-        severity: "high" | "medium" | "low";
+        severity: "high" | "medium" | "low" | "critical";
         reason: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+        recommendation?: string | undefined;
+        description?: string | undefined;
     }[];
     scenarios: {
         id: string;
@@ -330,8 +534,8 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         title: string;
         targetPath: string;
         steps: {
-            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             description: string;
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
             value?: string | undefined;
             target?: string | undefined;
         }[];
@@ -353,6 +557,41 @@ export declare const GapAnalysisSchema: z.ZodObject<{
         outputPath: string;
     }[];
     coverageWarning?: "auth-required" | "budget-exceeded" | "low-coverage" | "navigation-failures" | undefined;
+    costIntelligence?: {
+        maxOutputTokensPerLlmCall: number;
+        budgetRole: "max-output-tokens-per-llm-call";
+        records: {
+            provider: string;
+            model: string;
+            inputTokens: number;
+            outputTokens: number;
+            operationType: "scenario-generation";
+            timestamp: string;
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            estimatedCostUsd?: number | undefined;
+            promptHash?: string | undefined;
+            resultHash?: string | undefined;
+            notes?: string | undefined;
+        }[];
+        budgetWarnings: string[];
+        usageSummary: {
+            dataQuality: "none" | "actual" | "estimated" | "mixed";
+            totalInputTokens: number;
+            totalOutputTokens: number;
+        };
+        repeatedOperations: {
+            recommendation: string;
+            promptHash: string;
+            count: number;
+        }[];
+        deterministicMaturity: {
+            label: string;
+            level: number;
+            rationale: string;
+            ceilingNote?: string | undefined;
+        };
+        conversionRecommendations: string[];
+    } | undefined;
 }>;
 export type GapAnalysis = z.infer<typeof GapAnalysisSchema>;
 export type Gap = z.infer<typeof GapSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"gap-analysis.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/gap-analysis.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;EAMpB,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAIxC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAgBzB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUhC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}
+{"version":3,"file":"gap-analysis.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/gap-analysis.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;EAQpB,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAIxC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EAgBzB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUhC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

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

@@ -1,10 +1,13 @@
 import { z } from 'zod';
+import { CostIntelligenceSchema } from './cost-intelligence.schema.js';
 export const GapSchema = z.object({
     id: z.string(),
     path: z.string(),
-    severity: z.enum(['high', 'medium', 'low']),
+    severity: z.enum(['critical', 'high', 'medium', 'low']),
     reason: z.string(),
-    category: z.enum(['untested-route', 'a11y', 'console-error', 'broken-link']),
+    category: z.enum(['untested-route', 'a11y', 'console-error', 'broken-link', 'auth-surface', 'coverage']),
+    description: z.string().optional(),
+    recommendation: z.string().optional(),
 });
 export const FrameworkRecommendationSchema = z.object({
     adapter: z.enum(['playwright', 'cypress-e2e', 'cypress-component', 'api', 'accessibility']),
@@ -50,7 +53,7 @@ export const GeneratedTestSchema = z.object({
 export const GapAnalysisSchema = z.object({
     analyzedAt: z.string().datetime(),
     mode: z.enum(['url-only', 'url-repo', 'auth-required']),
-    releaseConfidence: z.number().min(0).max(100),
+    releaseConfidence: z.union([z.number().min(0).max(100), z.null()]),
     coveragePagesScanned: z.number().int().min(0),
     coverageBudgetExceeded: z.boolean(),
     coverageWarning: z
@@ -59,4 +62,5 @@ export const GapAnalysisSchema = z.object({
     gaps: z.array(GapSchema),
     scenarios: z.array(NeutralScenarioSchema),
     generatedTests: z.array(GeneratedTestSchema),
+    costIntelligence: CostIntelligenceSchema.optional(),
 });

package/dist/schemas/index.d.ts

@@ -1,6 +1,8 @@
-export { HarnessConfigSchema, AuthConfigSchema, DetectedAuthSchema, AuthPathRequirementsSchema, AuthPathSchema, AuthExplorationSchema, type ExplorerType, type AdapterType, type FormLoginAuthConfig, type StorageStateAuthConfig, type AuthConfig, type HarnessConfig, type DetectedAuth, type AuthPathRequirements, type AuthPath, type AuthExploration, } from './config.schema.js';
+export { HarnessConfigSchema, resolveMaxOutputTokensPerLlmCall, AuthConfigSchema, DetectedAuthSchema, AuthPathRequirementsSchema, AuthPathSchema, AuthExplorationSchema, type ExplorerType, type AdapterType, type FormLoginAuthConfig, type StorageStateAuthConfig, type AuthConfig, type HarnessConfig, type DetectedAuth, type AuthPathRequirements, type AuthPath, type AuthExploration, } from './config.schema.js';
 export { DecisionLogEntrySchema, type DecisionLogEntry, } from './decision-log.schema.js';
 export { RouteInventorySchema, RouteSchema, A11yViolationSchema, BrokenLinkSchema, type RouteInventory, type Route, } from './route-inventory.schema.js';
 export { GapAnalysisSchema, GapSchema, NeutralScenarioSchema, GeneratedTestSchema, TestStepSchema, FrameworkRecommendationSchema, type GapAnalysis, type Gap, type NeutralScenario, type GeneratedTest, type TestStep, type FrameworkRecommendation, } from './gap-analysis.schema.js';
+export { CostIntelligenceSchema, LlmUsageRecordSchema, LlmDataQualitySchema, LlmOperationTypeSchema, RepeatedAiPatternSchema, DeterministicMaturitySchema, type CostIntelligence, type LlmUsageRecord, type LlmDataQuality, type LlmOperationType, type RepeatedAiPattern, type DeterministicMaturity, } from './cost-intelligence.schema.js';
 export { RepoAnalysisSchema, type RepoAnalysis, } from './repo-analysis.schema.js';
+export { PublicSurfaceSchema, PublicSurfaceViolationSchema, PublicSurfaceBrokenLinkSchema, type PublicSurface, type PublicSurfaceViolation, type PublicSurfaceBrokenLink, } from './public-surface.schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,cAAc,EACd,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,KAAK,eAAe,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,KAAK,GACX,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,iBAAiB,EACjB,SAAS,EACT,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,6BAA6B,EAC7B,KAAK,WAAW,EAChB,KAAK,GAAG,EACR,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,uBAAuB,GAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,GAClB,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,gCAAgC,EAChC,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,cAAc,EACd,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,QAAQ,EACb,KAAK,eAAe,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,GACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,KAAK,GACX,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,iBAAiB,EACjB,SAAS,EACT,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,6BAA6B,EAC7B,KAAK,WAAW,EAChB,KAAK,GAAG,EACR,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,uBAAuB,GAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,GAC3B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,KAAK,YAAY,GAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,mBAAmB,EACnB,4BAA4B,EAC5B,6BAA6B,EAC7B,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,GAC7B,MAAM,4BAA4B,CAAC"}

package/dist/schemas/index.js

@@ -1,5 +1,7 @@
-export { HarnessConfigSchema, AuthConfigSchema, DetectedAuthSchema, AuthPathRequirementsSchema, AuthPathSchema, AuthExplorationSchema, } from './config.schema.js';
+export { HarnessConfigSchema, resolveMaxOutputTokensPerLlmCall, AuthConfigSchema, DetectedAuthSchema, AuthPathRequirementsSchema, AuthPathSchema, AuthExplorationSchema, } from './config.schema.js';
 export { DecisionLogEntrySchema, } from './decision-log.schema.js';
 export { RouteInventorySchema, RouteSchema, A11yViolationSchema, BrokenLinkSchema, } from './route-inventory.schema.js';
 export { GapAnalysisSchema, GapSchema, NeutralScenarioSchema, GeneratedTestSchema, TestStepSchema, FrameworkRecommendationSchema, } from './gap-analysis.schema.js';
+export { CostIntelligenceSchema, LlmUsageRecordSchema, LlmDataQualitySchema, LlmOperationTypeSchema, RepeatedAiPatternSchema, DeterministicMaturitySchema, } from './cost-intelligence.schema.js';
 export { RepoAnalysisSchema, } from './repo-analysis.schema.js';
+export { PublicSurfaceSchema, PublicSurfaceViolationSchema, PublicSurfaceBrokenLinkSchema, } from './public-surface.schema.js';