@qulib/core 0.1.0

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

@@ -0,0 +1,363 @@
+import { z } from 'zod';
+export declare const GapSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    severity: z.ZodEnum<["high", "medium", "low"]>;
+    reason: z.ZodString;
+    category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link"]>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    id: string;
+    severity: "high" | "medium" | "low";
+    reason: string;
+    category: "untested-route" | "a11y" | "console-error" | "broken-link";
+}, {
+    path: string;
+    id: string;
+    severity: "high" | "medium" | "low";
+    reason: string;
+    category: "untested-route" | "a11y" | "console-error" | "broken-link";
+}>;
+export declare const FrameworkRecommendationSchema: z.ZodObject<{
+    adapter: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "api", "accessibility"]>;
+    reason: z.ZodString;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+    confidence: "high" | "medium" | "low";
+}, {
+    reason: string;
+    adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+    confidence: "high" | "medium" | "low";
+}>;
+export declare const TestStepSchema: z.ZodObject<{
+    action: z.ZodEnum<["navigate", "click", "type", "assert-visible", "assert-hidden", "assert-text", "assert-disabled", "assert-count", "wait", "api-call"]>;
+    target: z.ZodOptional<z.ZodString>;
+    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;
+    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;
+    value?: string | undefined;
+    target?: string | undefined;
+}>;
+export declare const NeutralScenarioSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    targetPath: z.ZodString;
+    targetComponent: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<["navigate", "click", "type", "assert-visible", "assert-hidden", "assert-text", "assert-disabled", "assert-count", "wait", "api-call"]>;
+        target: z.ZodOptional<z.ZodString>;
+        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;
+        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;
+        value?: string | undefined;
+        target?: string | undefined;
+    }>, "many">;
+    tags: z.ZodArray<z.ZodString, "many">;
+    recommendations: z.ZodArray<z.ZodObject<{
+        adapter: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "api", "accessibility"]>;
+        reason: z.ZodString;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        confidence: "high" | "medium" | "low";
+    }, {
+        reason: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        confidence: "high" | "medium" | "low";
+    }>, "many">;
+    sourceGapIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    title: string;
+    targetPath: string;
+    steps: {
+        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
+        description: string;
+        value?: string | undefined;
+        target?: string | undefined;
+    }[];
+    tags: string[];
+    recommendations: {
+        reason: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        confidence: "high" | "medium" | "low";
+    }[];
+    sourceGapIds: string[];
+    targetComponent?: string | undefined;
+}, {
+    id: string;
+    description: string;
+    title: string;
+    targetPath: string;
+    steps: {
+        action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
+        description: string;
+        value?: string | undefined;
+        target?: string | undefined;
+    }[];
+    tags: string[];
+    recommendations: {
+        reason: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        confidence: "high" | "medium" | "low";
+    }[];
+    sourceGapIds: string[];
+    targetComponent?: string | undefined;
+}>;
+export declare const GeneratedTestSchema: z.ZodObject<{
+    scenarioId: z.ZodString;
+    adapter: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "api", "accessibility"]>;
+    filename: z.ZodString;
+    code: z.ZodString;
+    source: z.ZodEnum<["llm", "template"]>;
+    outputPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+    scenarioId: string;
+    filename: string;
+    source: "llm" | "template";
+    outputPath: string;
+}, {
+    code: string;
+    adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+    scenarioId: string;
+    filename: string;
+    source: "llm" | "template";
+    outputPath: string;
+}>;
+export declare const GapAnalysisSchema: z.ZodObject<{
+    analyzedAt: z.ZodString;
+    mode: z.ZodEnum<["url-only", "url-repo"]>;
+    releaseConfidence: z.ZodNumber;
+    coveragePagesScanned: z.ZodNumber;
+    coverageBudgetExceeded: z.ZodBoolean;
+    coverageWarning: z.ZodOptional<z.ZodEnum<["budget-exceeded", "low-coverage", "navigation-failures"]>>;
+    gaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        severity: z.ZodEnum<["high", "medium", "low"]>;
+        reason: z.ZodString;
+        category: z.ZodEnum<["untested-route", "a11y", "console-error", "broken-link"]>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        severity: "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+    }, {
+        path: string;
+        id: string;
+        severity: "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+    }>, "many">;
+    scenarios: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        targetPath: z.ZodString;
+        targetComponent: z.ZodOptional<z.ZodString>;
+        steps: z.ZodArray<z.ZodObject<{
+            action: z.ZodEnum<["navigate", "click", "type", "assert-visible", "assert-hidden", "assert-text", "assert-disabled", "assert-count", "wait", "api-call"]>;
+            target: z.ZodOptional<z.ZodString>;
+            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;
+            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;
+            value?: string | undefined;
+            target?: string | undefined;
+        }>, "many">;
+        tags: z.ZodArray<z.ZodString, "many">;
+        recommendations: z.ZodArray<z.ZodObject<{
+            adapter: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "api", "accessibility"]>;
+            reason: z.ZodString;
+            confidence: z.ZodEnum<["high", "medium", "low"]>;
+        }, "strip", z.ZodTypeAny, {
+            reason: string;
+            adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+            confidence: "high" | "medium" | "low";
+        }, {
+            reason: string;
+            adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+            confidence: "high" | "medium" | "low";
+        }>, "many">;
+        sourceGapIds: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        title: string;
+        targetPath: string;
+        steps: {
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
+            description: string;
+            value?: string | undefined;
+            target?: string | undefined;
+        }[];
+        tags: string[];
+        recommendations: {
+            reason: string;
+            adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+            confidence: "high" | "medium" | "low";
+        }[];
+        sourceGapIds: string[];
+        targetComponent?: string | undefined;
+    }, {
+        id: string;
+        description: string;
+        title: string;
+        targetPath: string;
+        steps: {
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
+            description: string;
+            value?: string | undefined;
+            target?: string | undefined;
+        }[];
+        tags: string[];
+        recommendations: {
+            reason: string;
+            adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+            confidence: "high" | "medium" | "low";
+        }[];
+        sourceGapIds: string[];
+        targetComponent?: string | undefined;
+    }>, "many">;
+    generatedTests: z.ZodArray<z.ZodObject<{
+        scenarioId: z.ZodString;
+        adapter: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "api", "accessibility"]>;
+        filename: z.ZodString;
+        code: z.ZodString;
+        source: z.ZodEnum<["llm", "template"]>;
+        outputPath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        scenarioId: string;
+        filename: string;
+        source: "llm" | "template";
+        outputPath: string;
+    }, {
+        code: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        scenarioId: string;
+        filename: string;
+        source: "llm" | "template";
+        outputPath: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    analyzedAt: string;
+    mode: "url-only" | "url-repo";
+    releaseConfidence: number;
+    coveragePagesScanned: number;
+    coverageBudgetExceeded: boolean;
+    gaps: {
+        path: string;
+        id: string;
+        severity: "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+    }[];
+    scenarios: {
+        id: string;
+        description: string;
+        title: string;
+        targetPath: string;
+        steps: {
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
+            description: string;
+            value?: string | undefined;
+            target?: string | undefined;
+        }[];
+        tags: string[];
+        recommendations: {
+            reason: string;
+            adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+            confidence: "high" | "medium" | "low";
+        }[];
+        sourceGapIds: string[];
+        targetComponent?: string | undefined;
+    }[];
+    generatedTests: {
+        code: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        scenarioId: string;
+        filename: string;
+        source: "llm" | "template";
+        outputPath: string;
+    }[];
+    coverageWarning?: "budget-exceeded" | "low-coverage" | "navigation-failures" | undefined;
+}, {
+    analyzedAt: string;
+    mode: "url-only" | "url-repo";
+    releaseConfidence: number;
+    coveragePagesScanned: number;
+    coverageBudgetExceeded: boolean;
+    gaps: {
+        path: string;
+        id: string;
+        severity: "high" | "medium" | "low";
+        reason: string;
+        category: "untested-route" | "a11y" | "console-error" | "broken-link";
+    }[];
+    scenarios: {
+        id: string;
+        description: string;
+        title: string;
+        targetPath: string;
+        steps: {
+            action: "type" | "navigate" | "click" | "assert-visible" | "assert-hidden" | "assert-text" | "assert-disabled" | "assert-count" | "wait" | "api-call";
+            description: string;
+            value?: string | undefined;
+            target?: string | undefined;
+        }[];
+        tags: string[];
+        recommendations: {
+            reason: string;
+            adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+            confidence: "high" | "medium" | "low";
+        }[];
+        sourceGapIds: string[];
+        targetComponent?: string | undefined;
+    }[];
+    generatedTests: {
+        code: string;
+        adapter: "playwright" | "cypress-e2e" | "cypress-component" | "api" | "accessibility";
+        scenarioId: string;
+        filename: string;
+        source: "llm" | "template";
+        outputPath: string;
+    }[];
+    coverageWarning?: "budget-exceeded" | "low-coverage" | "navigation-failures" | undefined;
+}>;
+export type GapAnalysis = z.infer<typeof GapAnalysisSchema>;
+export type Gap = z.infer<typeof GapSchema>;
+export type NeutralScenario = z.infer<typeof NeutralScenarioSchema>;
+export type GeneratedTest = z.infer<typeof GeneratedTestSchema>;
+export type TestStep = z.infer<typeof TestStepSchema>;
+export type FrameworkRecommendation = z.infer<typeof FrameworkRecommendationSchema>;
+//# sourceMappingURL=gap-analysis.schema.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU5B,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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export const GapSchema = z.object({
+    id: z.string(),
+    path: z.string(),
+    severity: z.enum(['high', 'medium', 'low']),
+    reason: z.string(),
+    category: z.enum(['untested-route', 'a11y', 'console-error', 'broken-link']),
+});
+export const FrameworkRecommendationSchema = z.object({
+    adapter: z.enum(['playwright', 'cypress-e2e', 'cypress-component', 'api', 'accessibility']),
+    reason: z.string(),
+    confidence: z.enum(['high', 'medium', 'low']),
+});
+export const TestStepSchema = z.object({
+    action: z.enum([
+        'navigate',
+        'click',
+        'type',
+        'assert-visible',
+        'assert-hidden',
+        'assert-text',
+        'assert-disabled',
+        'assert-count',
+        'wait',
+        'api-call',
+    ]),
+    target: z.string().optional(),
+    value: z.string().optional(),
+    description: z.string(),
+});
+export const NeutralScenarioSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    description: z.string(),
+    targetPath: z.string(),
+    targetComponent: z.string().optional(),
+    steps: z.array(TestStepSchema),
+    tags: z.array(z.string()),
+    recommendations: z.array(FrameworkRecommendationSchema),
+    sourceGapIds: z.array(z.string()),
+});
+export const GeneratedTestSchema = z.object({
+    scenarioId: z.string(),
+    adapter: z.enum(['playwright', 'cypress-e2e', 'cypress-component', 'api', 'accessibility']),
+    filename: z.string(),
+    code: z.string(),
+    source: z.enum(['llm', 'template']),
+    outputPath: z.string(),
+});
+export const GapAnalysisSchema = z.object({
+    analyzedAt: z.string().datetime(),
+    mode: z.enum(['url-only', 'url-repo']),
+    releaseConfidence: z.number().min(0).max(100),
+    coveragePagesScanned: z.number().int().min(0),
+    coverageBudgetExceeded: z.boolean(),
+    coverageWarning: z.enum(['budget-exceeded', 'low-coverage', 'navigation-failures']).optional(),
+    gaps: z.array(GapSchema),
+    scenarios: z.array(NeutralScenarioSchema),
+    generatedTests: z.array(GeneratedTestSchema),
+});

package/dist/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export { HarnessConfigSchema, AuthConfigSchema, type ExplorerType, type AdapterType, type FormLoginAuthConfig, type StorageStateAuthConfig, type AuthConfig, type HarnessConfig, } 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 { RepoAnalysisSchema, type RepoAnalysis, } from './repo-analysis.schema.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,UAAU,EACf,KAAK,aAAa,GACnB,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"}

package/dist/schemas/index.js

@@ -0,0 +1,5 @@
+export { HarnessConfigSchema, AuthConfigSchema, } 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 { RepoAnalysisSchema, } from './repo-analysis.schema.js';

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

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+export declare const RepoRouteSchema: z.ZodObject<{
+    path: z.ZodString;
+    file: z.ZodString;
+    method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "unknown"]>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    file: string;
+    method: "unknown" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+}, {
+    path: string;
+    file: string;
+    method: "unknown" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+}>;
+export declare const TestFileSchema: z.ZodObject<{
+    file: z.ZodString;
+    type: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "jest", "vitest", "other"]>;
+    coveredPaths: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other";
+    file: string;
+    coveredPaths: string[];
+}, {
+    type: "playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other";
+    file: string;
+    coveredPaths: string[];
+}>;
+export declare const CypressStructureSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    e2eFolder: z.ZodOptional<z.ZodString>;
+    componentFolder: z.ZodOptional<z.ZodString>;
+    fixturesFolder: z.ZodOptional<z.ZodString>;
+    supportFolder: z.ZodOptional<z.ZodString>;
+    hasCommandsFile: z.ZodBoolean;
+    existingE2eFiles: z.ZodArray<z.ZodString, "many">;
+    existingComponentFiles: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    detected: boolean;
+    hasCommandsFile: boolean;
+    existingE2eFiles: string[];
+    existingComponentFiles: string[];
+    e2eFolder?: string | undefined;
+    componentFolder?: string | undefined;
+    fixturesFolder?: string | undefined;
+    supportFolder?: string | undefined;
+}, {
+    detected: boolean;
+    hasCommandsFile: boolean;
+    existingE2eFiles: string[];
+    existingComponentFiles: string[];
+    e2eFolder?: string | undefined;
+    componentFolder?: string | undefined;
+    fixturesFolder?: string | undefined;
+    supportFolder?: string | undefined;
+}>;
+export declare const RepoAnalysisSchema: z.ZodObject<{
+    scannedAt: z.ZodString;
+    repoPath: z.ZodString;
+    routes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        file: z.ZodString;
+        method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "unknown"]>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        file: string;
+        method: "unknown" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    }, {
+        path: string;
+        file: string;
+        method: "unknown" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    }>, "many">;
+    testFiles: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        type: z.ZodEnum<["playwright", "cypress-e2e", "cypress-component", "jest", "vitest", "other"]>;
+        coveredPaths: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other";
+        file: string;
+        coveredPaths: string[];
+    }, {
+        type: "playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other";
+        file: string;
+        coveredPaths: string[];
+    }>, "many">;
+    missingTestIds: z.ZodArray<z.ZodString, "many">;
+    cypressStructure: z.ZodObject<{
+        detected: z.ZodBoolean;
+        e2eFolder: z.ZodOptional<z.ZodString>;
+        componentFolder: z.ZodOptional<z.ZodString>;
+        fixturesFolder: z.ZodOptional<z.ZodString>;
+        supportFolder: z.ZodOptional<z.ZodString>;
+        hasCommandsFile: z.ZodBoolean;
+        existingE2eFiles: z.ZodArray<z.ZodString, "many">;
+        existingComponentFiles: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        detected: boolean;
+        hasCommandsFile: boolean;
+        existingE2eFiles: string[];
+        existingComponentFiles: string[];
+        e2eFolder?: string | undefined;
+        componentFolder?: string | undefined;
+        fixturesFolder?: string | undefined;
+        supportFolder?: string | undefined;
+    }, {
+        detected: boolean;
+        hasCommandsFile: boolean;
+        existingE2eFiles: string[];
+        existingComponentFiles: string[];
+        e2eFolder?: string | undefined;
+        componentFolder?: string | undefined;
+        fixturesFolder?: string | undefined;
+        supportFolder?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    scannedAt: string;
+    routes: {
+        path: string;
+        file: string;
+        method: "unknown" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    }[];
+    repoPath: string;
+    testFiles: {
+        type: "playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other";
+        file: string;
+        coveredPaths: string[];
+    }[];
+    missingTestIds: string[];
+    cypressStructure: {
+        detected: boolean;
+        hasCommandsFile: boolean;
+        existingE2eFiles: string[];
+        existingComponentFiles: string[];
+        e2eFolder?: string | undefined;
+        componentFolder?: string | undefined;
+        fixturesFolder?: string | undefined;
+        supportFolder?: string | undefined;
+    };
+}, {
+    scannedAt: string;
+    routes: {
+        path: string;
+        file: string;
+        method: "unknown" | "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    }[];
+    repoPath: string;
+    testFiles: {
+        type: "playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other";
+        file: string;
+        coveredPaths: string[];
+    }[];
+    missingTestIds: string[];
+    cypressStructure: {
+        detected: boolean;
+        hasCommandsFile: boolean;
+        existingE2eFiles: string[];
+        existingComponentFiles: string[];
+        e2eFolder?: string | undefined;
+        componentFolder?: string | undefined;
+        fixturesFolder?: string | undefined;
+        supportFolder?: string | undefined;
+    };
+}>;
+export type RepoAnalysis = z.infer<typeof RepoAnalysisSchema>;
+export type CypressStructure = z.infer<typeof CypressStructureSchema>;
+//# sourceMappingURL=repo-analysis.schema.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const RepoRouteSchema = z.object({
+    path: z.string(),
+    file: z.string(),
+    method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'unknown']),
+});
+export const TestFileSchema = z.object({
+    file: z.string(),
+    type: z.enum(['playwright', 'cypress-e2e', 'cypress-component', 'jest', 'vitest', 'other']),
+    coveredPaths: z.array(z.string()),
+});
+export const CypressStructureSchema = z.object({
+    detected: z.boolean(),
+    e2eFolder: z.string().optional(),
+    componentFolder: z.string().optional(),
+    fixturesFolder: z.string().optional(),
+    supportFolder: z.string().optional(),
+    hasCommandsFile: z.boolean(),
+    existingE2eFiles: z.array(z.string()),
+    existingComponentFiles: z.array(z.string()),
+});
+export const RepoAnalysisSchema = z.object({
+    scannedAt: z.string().datetime(),
+    repoPath: z.string(),
+    routes: z.array(RepoRouteSchema),
+    testFiles: z.array(TestFileSchema),
+    missingTestIds: z.array(z.string()),
+    cypressStructure: CypressStructureSchema,
+});