@qulib/core 0.3.1 → 0.4.1

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,104 @@
+import { emitTelemetry } from '../../telemetry/emit.js';
+const DEFAULT_MODEL = 'claude-sonnet-4-20250514';
+function estimateTokensFromChars(chars) {
+    return Math.max(0, Math.ceil(chars / 4));
+}
+export class AnthropicProvider {
+    name = 'anthropic';
+    model;
+    telemetry;
+    sessionId;
+    constructor(options) {
+        this.model = options?.model ?? DEFAULT_MODEL;
+        this.telemetry = options?.telemetry;
+        this.sessionId = options?.sessionId ?? 'anonymous';
+    }
+    async call(prompt, maxOutputTokens) {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey)
+            throw new Error('ANTHROPIC_API_KEY is not set');
+        const started = Date.now();
+        emitTelemetry(this.telemetry, 'llm.call.started', this.sessionId, {
+            model: this.model,
+            promptLength: prompt.length,
+            provider: this.name,
+        });
+        try {
+            const response = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    max_tokens: maxOutputTokens,
+                    messages: [{ role: 'user', content: prompt }],
+                }),
+            });
+            if (!response.ok) {
+                const errBody = await response.text();
+                emitTelemetry(this.telemetry, 'llm.call.failed', this.sessionId, {
+                    model: this.model,
+                    error: `${response.status} ${errBody.slice(0, 500)}`,
+                    provider: this.name,
+                });
+                throw new Error(`LLM call failed: ${response.status} ${errBody}`);
+            }
+            const data = (await response.json());
+            const text = data.content.find((b) => b.type === 'text')?.text ?? '';
+            const inTok = data.usage?.input_tokens;
+            const outTok = data.usage?.output_tokens;
+            const durationMs = Date.now() - started;
+            let result;
+            if (typeof inTok === 'number' && typeof outTok === 'number') {
+                result = {
+                    text,
+                    usage: {
+                        provider: this.name,
+                        model: data.model ?? this.model,
+                        inputTokens: inTok,
+                        outputTokens: outTok,
+                        dataQuality: 'actual',
+                    },
+                };
+            }
+            else {
+                const inputTokens = estimateTokensFromChars(prompt.length);
+                const outputTokens = estimateTokensFromChars(text.length);
+                result = {
+                    text,
+                    usage: {
+                        provider: this.name,
+                        model: data.model ?? this.model,
+                        inputTokens,
+                        outputTokens,
+                        dataQuality: 'estimated',
+                    },
+                };
+            }
+            const u = result.usage;
+            emitTelemetry(this.telemetry, 'llm.call.completed', this.sessionId, {
+                model: this.model,
+                inputTokens: u.inputTokens,
+                outputTokens: u.outputTokens,
+                durationMs,
+                provider: this.name,
+            });
+            return result;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.startsWith('LLM call failed:')) {
+                throw err;
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            emitTelemetry(this.telemetry, 'llm.call.failed', this.sessionId, {
+                model: this.model,
+                error: msg.slice(0, 500),
+                provider: this.name,
+            });
+            throw err;
+        }
+    }
+}

package/dist/phases/act.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"act.d.ts","sourceRoot":"","sources":["../../src/phases/act.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAIrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,wBAAsB,GAAG,CACvB,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,GACxD,OAAO,CAAC,IAAI,CAAC,CA+Cf"}
+{"version":3,"file":"act.d.ts","sourceRoot":"","sources":["../../src/phases/act.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAIrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIrE,wBAAsB,GAAG,CACvB,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,GACxD,OAAO,CAAC,IAAI,CAAC,CA6Df"}

package/dist/phases/act.js

@@ -2,20 +2,30 @@ import { join } from 'node:path';
 import { writeJsonReport } from '../reporters/json-reporter.js';
 import { writeMarkdownReport } from '../reporters/markdown-reporter.js';
 import { logDecision } from '../harness/decision-logger.js';
+import { emitTelemetry } from '../telemetry/emit.js';
+import { resolveScanStateBaseDir } from '../harness/state-manager.js';
 export async function act(analysis, config, artifacts = { writeArtifacts: true }) {
-    const outputDir = join(process.cwd(), 'output');
-    const logOpts = { persist: artifacts.writeArtifacts, memory: artifacts.decisionMemory };
+    const sessionId = artifacts.telemetrySessionId ?? 'none';
+    const reportDir = join(process.cwd(), 'output');
+    const logOpts = {
+        persist: artifacts.writeArtifacts,
+        memory: artifacts.decisionMemory,
+        outputDir: config.outputDir,
+    };
     const log = artifacts.writeArtifacts ? console.log : console.error;
+    emitTelemetry(artifacts.telemetry, 'phase.act.started', sessionId, {
+        writeArtifacts: artifacts.writeArtifacts,
+    });
     if (artifacts.writeArtifacts) {
-        await writeJsonReport(analysis, outputDir);
-        await writeMarkdownReport(analysis, outputDir);
+        await writeJsonReport(analysis, reportDir);
+        await writeMarkdownReport(analysis, reportDir);
     }
     await logDecision({
         timestamp: new Date().toISOString(),
         phase: 'act',
         decision: 'reports-written',
         reason: artifacts.writeArtifacts
-            ? `Wrote JSON and Markdown reports to ${outputDir}`
+            ? `Wrote JSON and Markdown reports to ${reportDir}`
             : 'Skipped writing reports (ephemeral run)',
         metadata: {
             gapCount: analysis.gaps.length,
@@ -24,6 +34,10 @@ export async function act(analysis, config, artifacts = { writeArtifacts: true }
             requireHumanReview: config.requireHumanReview,
         },
     }, logOpts);
+    emitTelemetry(artifacts.telemetry, 'phase.act.completed', sessionId, {
+        gapCount: analysis.gaps.length,
+        wroteReports: artifacts.writeArtifacts,
+    });
     log('\n[qulib] Analysis complete');
     log(`  Gaps found:          ${analysis.gaps.length}`);
     log(`  Scenarios generated: ${analysis.scenarios.length}`);
@@ -35,7 +49,7 @@ export async function act(analysis, config, artifacts = { writeArtifacts: true }
         log('\n[qulib] Human review required before applying any generated output.');
         if (artifacts.writeArtifacts) {
             log('  Reports:   output/report.json and output/report.md');
-            log('  Decisions: .scan-state/decision-log.json');
+            log(`  Decisions: ${join(resolveScanStateBaseDir(config.outputDir), 'decision-log.json')}`);
         }
         else {
             log('  Ephemeral run: inspect JSON printed to stdout (no files written).');

package/dist/phases/observe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../src/phases/observe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,sCAAsC,CAAC;AACjG,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAK3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;CAC3B;AAED,wBAAsB,OAAO,CAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,GACxD,OAAO,CAAC,aAAa,CAAC,CAoDxB"}
+{"version":3,"file":"observe.d.ts","sourceRoot":"","sources":["../../src/phases/observe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,sCAAsC,CAAC;AACjG,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAK3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGrE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;CAC3B;AAED,wBAAsB,OAAO,CAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,GACxD,OAAO,CAAC,aAAa,CAAC,CAuExB"}

package/dist/phases/observe.js

@@ -4,10 +4,20 @@ import { createExplorer } from '../tools/explorer-factory.js';
 import { scanRepo } from '../tools/repo-scanner.js';
 import { StateManager } from '../harness/state-manager.js';
 import { logDecision } from '../harness/decision-logger.js';
+import { emitTelemetry } from '../telemetry/emit.js';
 export async function observe(baseUrl, repoPath, config, artifacts = { writeArtifacts: true }) {
+    const sessionId = artifacts.telemetrySessionId ?? 'none';
     const explorer = createExplorer(config.explorer);
-    const stateManager = new StateManager();
-    const logOpts = { persist: artifacts.writeArtifacts, memory: artifacts.decisionMemory };
+    const stateManager = new StateManager(config.outputDir);
+    const logOpts = {
+        persist: artifacts.writeArtifacts,
+        memory: artifacts.decisionMemory,
+        outputDir: config.outputDir,
+    };
+    emitTelemetry(artifacts.telemetry, 'phase.observe.started', sessionId, {
+        baseUrl,
+        hasRepoPath: Boolean(repoPath),
+    });
     const rawRoutes = await explorer.explore(baseUrl, config, artifacts);
     const routes = RouteInventorySchema.parse(rawRoutes);
     if (artifacts.writeArtifacts) {
@@ -29,6 +39,10 @@ export async function observe(baseUrl, repoPath, config, artifacts = { writeArti
     if (repoPath) {
         const rawRepo = await scanRepo(repoPath);
         repo = RepoAnalysisSchema.parse(rawRepo);
+        emitTelemetry(artifacts.telemetry, 'repo.scanned', sessionId, {
+            routeCount: repo.routes.length,
+            testFileCount: repo.testFiles.length,
+        });
         if (artifacts.writeArtifacts) {
             await stateManager.writeState('repo-inventory.json', repo, RepoAnalysisSchema);
         }
@@ -44,5 +58,9 @@ export async function observe(baseUrl, repoPath, config, artifacts = { writeArti
             },
         }, logOpts);
     }
+    emitTelemetry(artifacts.telemetry, 'phase.observe.completed', sessionId, {
+        routeCount: routes.routes.length,
+        repoScanned: Boolean(repo),
+    });
     return { routes, repo };
 }

package/dist/phases/think-finalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"think-finalize.d.ts","sourceRoot":"","sources":["../../src/phases/think-finalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACnG,OAAO,EAA4C,KAAK,WAAW,EAAwB,MAAM,mCAAmC,CAAC;AAQrI,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,gBAAgB,GAAG,kBAAkB,CAAC,CAAC;AAEtG,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,EACzD,WAAW,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,sBAAsB,GAAG,mBAAmB,GAAG,MAAM,CAAC,GAC9F,OAAO,CAAC,WAAW,CAAC,CAwKtB"}
+{"version":3,"file":"think-finalize.d.ts","sourceRoot":"","sources":["../../src/phases/think-finalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACnG,OAAO,EAA4C,KAAK,WAAW,EAAwB,MAAM,mCAAmC,CAAC;AAQrI,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,gBAAgB,GAAG,kBAAkB,CAAC,CAAC;AAEtG,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,EACzD,WAAW,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,sBAAsB,GAAG,mBAAmB,GAAG,MAAM,CAAC,GAC9F,OAAO,CAAC,WAAW,CAAC,CAiLtB"}

package/dist/phases/think-finalize.js

@@ -7,8 +7,12 @@ import { buildGapPrompt } from '../llm/context-builder.js';
 import { assembleCostIntelligence } from '../llm/cost-intelligence.js';
 import { hashForCostIntelligence } from '../llm/content-hash.js';
 export async function finalizeGapAnalysisFromDraft(draft, config, artifacts = { writeArtifacts: true }, costContext) {
-    const stateManager = new StateManager();
-    const logOpts = { persist: artifacts.writeArtifacts, memory: artifacts.decisionMemory };
+    const stateManager = new StateManager(config.outputDir);
+    const logOpts = {
+        persist: artifacts.writeArtifacts,
+        memory: artifacts.decisionMemory,
+        outputDir: config.outputDir,
+    };
     const partialAnalysis = GapAnalysisSchema.parse({
         ...draft,
         scenarios: [],
@@ -60,7 +64,12 @@ export async function finalizeGapAnalysisFromDraft(draft, config, artifacts = {
         const prompt = buildGapPrompt(partialAnalysis.gaps, config.testGenerationLimit);
         const promptHash = hashForCostIntelligence(prompt);
         try {
-            const llmResult = await callLLM(prompt, maxOut);
+            const llmResult = await callLLM(prompt, maxOut, {
+                llmProvider: config.llmProvider,
+                llmModel: config.llmModel,
+                telemetry: artifacts.telemetry,
+                telemetrySessionId: artifacts.telemetrySessionId,
+            });
             const resultHash = hashForCostIntelligence(llmResult.text);
             const usage = llmResult.usage;
             llmRecords.push({

package/dist/phases/think.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../src/phases/think.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACxF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAGrE,wBAAsB,KAAK,CACzB,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,GACxD,OAAO,CAAC,WAAW,CAAC,CAqCtB;AAED,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACnE,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../src/phases/think.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACxF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIrE,wBAAsB,KAAK,CACzB,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,SAAS,GAAE,mBAA8C,GACxD,OAAO,CAAC,WAAW,CAAC,CAmDtB;AAED,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACnE,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/phases/think.js

@@ -2,9 +2,16 @@ import { GapAnalysisSchema } from '../schemas/gap-analysis.schema.js';
 import { analyzeGaps } from '../tools/gap-engine.js';
 import { logDecision } from '../harness/decision-logger.js';
 import { finalizeGapAnalysisFromDraft } from './think-finalize.js';
+import { emitTelemetry } from '../telemetry/emit.js';
 export async function think(observed, config, artifacts = { writeArtifacts: true }) {
+    const sessionId = artifacts.telemetrySessionId ?? 'none';
     const mode = observed.repo ? 'url-repo' : 'url-only';
-    const logOpts = { persist: artifacts.writeArtifacts, memory: artifacts.decisionMemory };
+    const logOpts = {
+        persist: artifacts.writeArtifacts,
+        memory: artifacts.decisionMemory,
+        outputDir: config.outputDir,
+    };
+    emitTelemetry(artifacts.telemetry, 'phase.think.started', sessionId, { mode });
     const gapBlock = analyzeGaps(observed.routes, observed.repo, mode, config);
     const draft = {
         analyzedAt: gapBlock.analyzedAt,
@@ -31,6 +38,11 @@ export async function think(observed, config, artifacts = { writeArtifacts: true
             releaseConfidence: partialAnalysis.releaseConfidence,
         },
     }, logOpts);
-    return finalizeGapAnalysisFromDraft(draft, config, artifacts);
+    const finalized = await finalizeGapAnalysisFromDraft(draft, config, artifacts);
+    emitTelemetry(artifacts.telemetry, 'phase.think.completed', sessionId, {
+        gapCount: finalized.gaps.length,
+        mode: finalized.mode,
+    });
+    return finalized;
 }
 export { finalizeGapAnalysisFromDraft } from './think-finalize.js';

package/dist/schemas/automation-maturity.schema.d.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+export declare const AutomationMaturityDimensionSchema: 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[];
+}>;
+export declare const AutomationMaturitySchema: 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[];
+}>;
+export type AutomationMaturityDimension = z.infer<typeof AutomationMaturityDimensionSchema>;
+export type AutomationMaturity = z.infer<typeof AutomationMaturitySchema>;
+//# sourceMappingURL=automation-maturity.schema.d.ts.map

package/dist/schemas/automation-maturity.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automation-maturity.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/automation-maturity.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;EAa5C,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQnC,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/automation-maturity.schema.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const AutomationMaturityDimensionSchema = z.object({
+    dimension: z.enum([
+        'test-coverage-breadth',
+        'framework-adoption',
+        'test-id-hygiene',
+        'ci-integration',
+        'auth-test-coverage',
+        'component-test-ratio',
+    ]),
+    score: z.number().min(0).max(100),
+    weight: z.number().min(0).max(1),
+    evidence: z.array(z.string()),
+    recommendations: z.array(z.string()),
+});
+export const AutomationMaturitySchema = z.object({
+    computedAt: z.string().datetime(),
+    repoPath: z.string(),
+    overallScore: z.number().min(0).max(100),
+    level: z.number().int().min(1).max(5),
+    label: z.string(),
+    dimensions: z.array(AutomationMaturityDimensionSchema),
+    topRecommendations: z.array(z.string()),
+});