@mknrt/autotests-overkill 1.1.0

package/README.md

@@ -0,0 +1,117 @@
+# Autotests Overkill
+
+`Autotests Overkill` is a standalone AI-assisted testing platform for `autotests2`, `caseplatform-web`, and CI artifacts. It is designed for Codex-style work: inspect existing coverage, extract frontend contracts and runtime logic, generate draft specs, triage failures, and narrow rerun scope without silently mutating consumer repositories.
+
+## What v1.1 adds
+
+- Legacy widget contract extraction for files such as `dateRangeInput_control.js` and `dateRangeInput_singleton.js`
+- Stronger spec blueprints that reuse real `autotests2` setup, commands, helpers, and selector patterns
+- Acceptance coverage for both modern and legacy widgets
+- Knowledge-store-backed retrieval for asset search, area context, impact analysis, and blueprint support
+- Optional ReportPortal and GitLab adapters with graceful artifacts-first fallback
+- Codex plugin packaging via `.codex-plugin/plugin.json` and `.mcp.json`
+
+## Repository layout
+
+- `src/` implementation code
+- `mcp/` MCP entrypoint notes
+- `skills/` Codex skills for end-to-end workflows
+- `indexer/` indexing entrypoint notes
+- `connectors/` connector notes
+- `templates/` prompt and blueprint templates
+- `docs/` operator and integration documentation
+- `tests/` unit, integration, and acceptance checks
+
+## Install
+
+Published npm package install:
+
+1. Run `npm install -D @mknrt/autotests-overkill`.
+2. Copy `node_modules/@mknrt/autotests-overkill/overkill.config.example.json` to `overkill.config.json`.
+3. Set `repos.autotests2`, `repos.caseplatformWeb`, and `ci.artifactsRoot`.
+4. Run `npx autotests-overkill index`.
+
+Repository-local development:
+
+1. Run `npm install`.
+2. Copy `overkill.config.example.json` to `overkill.config.json`.
+3. Set `repos.autotests2`, `repos.caseplatformWeb`, and `ci.artifactsRoot`.
+4. Run `npm run build`.
+5. Run `npm run index`.
+
+## Daily workflow
+
+1. Refresh local knowledge with `npm run index`.
+2. Start the MCP server through the checked-in MCP manifest or by running `npx autotests-overkill mcp`.
+3. Use `find_frontend_contract`, `find_existing_test_assets`, and `generate_spec_blueprint` for a new feature draft.
+4. Use `summarize_ci_context`, `triage_failed_run`, and `analyze_diff_impact` for failure or change triage.
+5. Review generated output manually before editing `autotests2`.
+
+CLI commands:
+
+- `npx autotests-overkill index`
+- `npx autotests-overkill mcp`
+- `npx autotests-overkill acceptance coverage caption`
+- `npx autotests-overkill acceptance blueprint dateRangeField`
+
+## Verification commands
+
+- `npm run verify`
+- `npm run mcp:smoke`
+- `npm run acceptance:coverage`
+- `npm run acceptance:coverage:legacy`
+- `npm run acceptance:blueprint`
+- `npm run acceptance:failure`
+- `npm run acceptance:impact`
+
+## Consumer config
+
+The platform reads `overkill.config.json` with these keys:
+
+- `repos.autotests2`
+- `repos.caseplatformWeb`
+- `ci.artifactsRoot`
+- `ci.reportPortal.endpoint`
+- `ci.reportPortal.project`
+- `ci.reportPortal.token`
+- `ci.gitlab.baseUrl`
+- `ci.gitlab.projectId`
+- `ci.gitlab.token`
+- `cacheDir`
+
+The default path is local and artifacts-first. Missing ReportPortal or GitLab credentials do not break tools; the platform keeps using local stats, screenshots, videos, and captured API payloads.
+
+## MCP tools
+
+- `find_existing_test_assets`
+- `find_test_area_context`
+- `find_frontend_contract`
+- `find_frontend_runtime_logic`
+- `map_feature_to_existing_coverage`
+- `analyze_test_gaps`
+- `generate_spec_blueprint`
+- `recommend_selector_strategy`
+- `build_setup_teardown_plan`
+- `analyze_diff_impact`
+- `triage_failed_run`
+- `build_rerun_scope`
+- `summarize_ci_context`
+
+Every tool returns the same normalized shape:
+
+- `summary`
+- `evidence`
+- `recommended_actions`
+- `repo_paths`
+- `confidence`
+- `warnings`
+
+## Codex plugin packaging
+
+This repository can be consumed either from a Git checkout or as a published npm package:
+
+- `.codex-plugin/plugin.json` exposes the plugin metadata
+- `.mcp.json` registers the local MCP server command for checkout-based usage
+- `skills/` is auto-discovered as the bundled skill set
+
+See [consumer-integration.md](/C:/gitrep/autotests-overkill/docs/consumer-integration.md), [operator-cookbook.md](/C:/gitrep/autotests-overkill/docs/operator-cookbook.md), and [plugin-packaging.md](/C:/gitrep/autotests-overkill/docs/plugin-packaging.md) for setup details.

package/assets/overkill-logo.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="none">
+  <rect width="256" height="256" rx="40" fill="#0F4C81"/>
+  <path d="M58 176 92 90l29 61 35-81" stroke="#F4F7FB" stroke-linecap="round" stroke-linejoin="round" stroke-width="18"/>
+  <circle cx="58" cy="176" r="12" fill="#FFD166"/>
+  <circle cx="92" cy="90" r="12" fill="#FFD166"/>
+  <circle cx="121" cy="151" r="12" fill="#FFD166"/>
+  <circle cx="156" cy="70" r="12" fill="#FFD166"/>
+</svg>

package/assets/overkill-small.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <rect width="64" height="64" rx="14" fill="#0F4C81"/>
+  <path d="M18 45 28 20l8 18 10-22" stroke="#F4F7FB" stroke-linecap="round" stroke-linejoin="round" stroke-width="5"/>
+  <circle cx="18" cy="45" r="4" fill="#FFD166"/>
+  <circle cx="28" cy="20" r="4" fill="#FFD166"/>
+  <circle cx="36" cy="38" r="4" fill="#FFD166"/>
+  <circle cx="46" cy="16" r="4" fill="#FFD166"/>
+</svg>

package/dist/connectors/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../src/connectors/autotests2Connector.js';
+export * from '../src/connectors/caseplatformConnector.js';
+export * from '../src/connectors/ciArtifactsConnector.js';
+export * from '../src/connectors/diffConnector.js';

package/dist/connectors/index.js

@@ -0,0 +1,4 @@
+export * from '../src/connectors/autotests2Connector.js';
+export * from '../src/connectors/caseplatformConnector.js';
+export * from '../src/connectors/ciArtifactsConnector.js';
+export * from '../src/connectors/diffConnector.js';

package/dist/indexer/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../src/indexer/refreshPipeline.js';
+export * from '../src/indexer/extractors/frontendContractExtractor.js';
+export * from '../src/indexer/extractors/frontendRuntimeExtractor.js';
+export * from '../src/indexer/extractors/testAssetExtractor.js';

package/dist/indexer/index.js

@@ -0,0 +1,4 @@
+export * from '../src/indexer/refreshPipeline.js';
+export * from '../src/indexer/extractors/frontendContractExtractor.js';
+export * from '../src/indexer/extractors/frontendRuntimeExtractor.js';
+export * from '../src/indexer/extractors/testAssetExtractor.js';

package/dist/mcp/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../src/mcp/server.js';
+export * from '../src/mcp/registerTools.js';

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+export * from '../src/mcp/server.js';
+export * from '../src/mcp/registerTools.js';

package/dist/src/appContext.d.ts

@@ -0,0 +1,21 @@
+import { Autotests2Connector } from './connectors/autotests2Connector.js';
+import { CaseplatformConnector } from './connectors/caseplatformConnector.js';
+import { CiArtifactsConnector } from './connectors/ciArtifactsConnector.js';
+import { GitLabConnector } from './connectors/gitlabConnector.js';
+import { ReportPortalConnector } from './connectors/reportPortalConnector.js';
+import { type ConsumerConfig, type ConsumerConfigInput } from './config/consumerConfig.js';
+import { createKnowledgeDatabase } from './knowledge/database.js';
+export type AppContext = {
+    config: ConsumerConfig;
+    database: ReturnType<typeof createKnowledgeDatabase>;
+    autotests2: Autotests2Connector;
+    caseplatform: CaseplatformConnector;
+    ciArtifacts: CiArtifactsConnector;
+    gitlab: GitLabConnector;
+    reportPortal: ReportPortalConnector;
+};
+export declare function createAppContext(input?: {
+    config?: ConsumerConfig | ConsumerConfigInput;
+}): Promise<AppContext>;
+export declare function resolveRuntimeConfigPath(): string;
+export declare function createRuntimeAppContext(): Promise<AppContext>;

package/dist/src/appContext.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Autotests2Connector } from './connectors/autotests2Connector.js';
+import { CaseplatformConnector } from './connectors/caseplatformConnector.js';
+import { CiArtifactsConnector } from './connectors/ciArtifactsConnector.js';
+import { GitLabConnector } from './connectors/gitlabConnector.js';
+import { ReportPortalConnector } from './connectors/reportPortalConnector.js';
+import { createDefaultConsumerConfig, loadConsumerConfig, parseConsumerConfig } from './config/consumerConfig.js';
+import { createKnowledgeDatabase } from './knowledge/database.js';
+import { ensureDirectory } from './utils/fileUtils.js';
+export async function createAppContext(input) {
+    const config = input?.config
+        ? ('cacheDir' in input.config ? input.config : parseConsumerConfig(input.config))
+        : createDefaultConsumerConfig();
+    ensureDirectory(config.cacheDir);
+    const database = createKnowledgeDatabase(path.join(config.cacheDir, 'knowledge.db'));
+    return {
+        config,
+        database,
+        autotests2: new Autotests2Connector(config.repos.autotests2),
+        caseplatform: new CaseplatformConnector(config.repos.caseplatformWeb),
+        ciArtifacts: new CiArtifactsConnector(),
+        gitlab: new GitLabConnector(config.ci.gitlab),
+        reportPortal: new ReportPortalConnector(config.ci.reportPortal),
+    };
+}
+export function resolveRuntimeConfigPath() {
+    const explicitPath = process.env.OVERKILL_CONFIG_PATH;
+    if (explicitPath) {
+        return path.resolve(process.cwd(), explicitPath);
+    }
+    return path.resolve(process.cwd(), 'overkill.config.json');
+}
+export async function createRuntimeAppContext() {
+    const configPath = resolveRuntimeConfigPath();
+    const config = fs.existsSync(configPath)
+        ? loadConsumerConfig(configPath)
+        : createDefaultConsumerConfig();
+    return createAppContext({ config });
+}

package/dist/src/cli/indexKnowledge.d.ts

@@ -0,0 +1 @@
+export declare function runIndexKnowledge(): Promise<void>;

package/dist/src/cli/indexKnowledge.js

@@ -0,0 +1,11 @@
+import { createRuntimeAppContext } from '../appContext.js';
+import { refreshKnowledge } from '../indexer/refreshPipeline.js';
+import { isDirectExecution } from './shared.js';
+export async function runIndexKnowledge() {
+    const context = await createRuntimeAppContext();
+    const result = await refreshKnowledge(context);
+    console.log(JSON.stringify(result, null, 2));
+}
+if (isDirectExecution(import.meta.url)) {
+    await runIndexKnowledge();
+}

package/dist/src/cli/main.d.ts

@@ -0,0 +1,19 @@
+export type ParsedCliArgs = {
+    command: 'index';
+    args: string[];
+} | {
+    command: 'mcp';
+    args: string[];
+} | {
+    command: 'acceptance';
+    args: string[];
+} | {
+    command: 'help';
+    args: [];
+} | {
+    command: 'invalid';
+    args: string[];
+};
+export declare function parseCliArgs(argv: string[]): ParsedCliArgs;
+export declare function formatCliHelp(): string;
+export declare function runCli(argv?: string[]): Promise<void>;

package/dist/src/cli/main.js

@@ -0,0 +1,59 @@
+import { runIndexKnowledge } from './indexKnowledge.js';
+import { runAcceptanceCli } from './runAcceptance.js';
+import { startMcpServer } from './runMcpServer.js';
+import { isDirectExecution } from './shared.js';
+export function parseCliArgs(argv) {
+    const [command, ...args] = argv;
+    if (!command || command === '--help' || command === '-h' || command === 'help') {
+        return { command: 'help', args: [] };
+    }
+    if (command === 'index') {
+        return { command, args };
+    }
+    if (command === 'mcp') {
+        return { command, args };
+    }
+    if (command === 'acceptance') {
+        return { command, args };
+    }
+    return { command: 'invalid', args: [command, ...args] };
+}
+export function formatCliHelp() {
+    return [
+        'autotests-overkill <command>',
+        '',
+        'Commands:',
+        '  index                         Refresh the local knowledge cache.',
+        '  mcp                           Start the MCP server.',
+        '  acceptance <mode> [args...]   Run acceptance checks.',
+        '',
+        'Examples:',
+        '  npx @mknrt/autotests-overkill index',
+        '  npx @mknrt/autotests-overkill mcp',
+        '  npx @mknrt/autotests-overkill acceptance coverage caption',
+    ].join('\n');
+}
+export async function runCli(argv = process.argv.slice(2)) {
+    const parsed = parseCliArgs(argv);
+    if (parsed.command === 'help') {
+        console.log(formatCliHelp());
+        return;
+    }
+    if (parsed.command === 'invalid') {
+        console.error(`Unknown command '${parsed.args[0]}'.\n\n${formatCliHelp()}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (parsed.command === 'index') {
+        await runIndexKnowledge();
+        return;
+    }
+    if (parsed.command === 'mcp') {
+        await startMcpServer();
+        return;
+    }
+    await runAcceptanceCli(parsed.args);
+}
+if (isDirectExecution(import.meta.url)) {
+    await runCli();
+}

package/dist/src/cli/runAcceptance.d.ts

@@ -0,0 +1,21 @@
+import { type AppContext } from '../appContext.js';
+import type { NormalizedToolOutput } from '../contracts/toolOutput.js';
+export type AcceptanceMode = 'coverage' | 'failure' | 'impact' | 'blueprint';
+export type AcceptanceCheck = {
+    name: string;
+    passed: boolean;
+    detail: string;
+};
+export type AcceptanceReport = {
+    mode: AcceptanceMode;
+    target: string;
+    checks: AcceptanceCheck[];
+    output: Record<string, unknown>;
+};
+export declare function evaluateAcceptanceMode(mode: AcceptanceMode, args: string[], context: AppContext): Promise<AcceptanceReport>;
+export declare function evaluateCoverageAcceptance(contract: NormalizedToolOutput, gaps: NormalizedToolOutput, widget: string): AcceptanceCheck[];
+export declare function evaluateFailureAcceptance(triage: NormalizedToolOutput): AcceptanceCheck[];
+export declare function evaluateImpactAcceptance(impact: NormalizedToolOutput, changedFile: string): AcceptanceCheck[];
+export declare function evaluateBlueprintAcceptance(blueprint: NormalizedToolOutput, feature: string): AcceptanceCheck[];
+export declare function assertPassingChecks(report: AcceptanceReport): void;
+export declare function runAcceptanceCli(argv?: string[]): Promise<void>;

package/dist/src/cli/runAcceptance.js

@@ -0,0 +1,131 @@
+import { createRuntimeAppContext } from '../appContext.js';
+import { analyzeDiffImpact } from '../domain/analyzeDiffImpact.js';
+import { analyzeTestGaps } from '../domain/analyzeTestGaps.js';
+import { findFrontendContract } from '../domain/findFrontendContract.js';
+import { generateSpecBlueprint } from '../domain/generateSpecBlueprint.js';
+import { triageFailedRun } from '../domain/triageFailedRun.js';
+import { isDirectExecution } from './shared.js';
+export async function evaluateAcceptanceMode(mode, args, context) {
+    if (mode === 'coverage') {
+        const widget = args[0] ?? 'caption';
+        const [contract, gaps] = await Promise.all([
+            findFrontendContract({ widget }, context),
+            analyzeTestGaps({ widget }, context),
+        ]);
+        return {
+            mode,
+            target: widget,
+            checks: evaluateCoverageAcceptance(contract, gaps, widget),
+            output: { contract, gaps },
+        };
+    }
+    if (mode === 'failure') {
+        const triage = await triageFailedRun({
+            statsFile: `${context.config.repos.autotests2}/cypress/reports/test-stats.json`,
+            screenshotsRoot: `${context.config.repos.autotests2}/cypress/screenshots`,
+            videosRoot: `${context.config.repos.autotests2}/cypress/videos`,
+            apiCaptureRoot: `${context.config.repos.autotests2}/cypress/reports/api-capture`,
+        }, context);
+        return {
+            mode,
+            target: 'latest-failure-artifacts',
+            checks: evaluateFailureAcceptance(triage),
+            output: { triage },
+        };
+    }
+    if (mode === 'impact') {
+        const changedFile = args[0] ?? 'C:/gitrep/caseplatform-web/vcm/jqVCM/widget/caption/CaptionSingleton.ts';
+        const impact = await analyzeDiffImpact({ changedFiles: [changedFile] }, context);
+        return {
+            mode,
+            target: changedFile,
+            checks: evaluateImpactAcceptance(impact, changedFile),
+            output: { impact },
+        };
+    }
+    const feature = args[0] ?? 'caption';
+    const area = args[1];
+    const blueprint = await generateSpecBlueprint({ feature, area }, context);
+    return {
+        mode,
+        target: feature,
+        checks: evaluateBlueprintAcceptance(blueprint, feature),
+        output: { blueprint },
+    };
+}
+export function evaluateCoverageAcceptance(contract, gaps, widget) {
+    const hasNonEmptyContract = !/0 properties, 0 events, and 0 methods/.test(contract.summary);
+    return [
+        check('contract evidence', contract.evidence.length > 0, `Frontend contract for '${widget}' must contain evidence-backed files/snippets.`, `Collected ${contract.evidence.length} contract evidence item(s).`),
+        check('contract usefulness', hasNonEmptyContract, `Frontend contract for '${widget}' is empty, so coverage acceptance must fail instead of silently passing.`, contract.summary),
+        check('gap evidence', gaps.evidence.length > 0, `Gap analysis for '${widget}' must contain evidence and likely gap signals.`, `Collected ${gaps.evidence.length} gap evidence item(s).`),
+    ];
+}
+export function evaluateFailureAcceptance(triage) {
+    const hasStats = triage.evidence.some((item) => item.label === 'stats report');
+    const hasArtifacts = triage.evidence.some((item) => /failure screenshot|failure video|failed spec/.test(item.label));
+    return [
+        check('failure evidence', triage.evidence.length > 0, 'Failure acceptance requires evidence-backed triage output.', `Collected ${triage.evidence.length} evidence item(s).`),
+        check('stats report', hasStats, 'Failure acceptance requires the stats report evidence entry.', 'Stats report evidence is present.'),
+        check('artifact context', hasArtifacts, 'Failure acceptance requires at least one screenshot, video, or failed-spec evidence item.', 'Artifact context is present in the triage output.'),
+    ];
+}
+export function evaluateImpactAcceptance(impact, changedFile) {
+    const impactedSpecs = impact.evidence.filter((item) => item.label === 'impacted spec');
+    return [
+        check('impacted specs', impactedSpecs.length > 0, `Impact acceptance for '${changedFile}' must not pass when no impacted specs are found.`, `Mapped ${impactedSpecs.length} impacted spec(s).`),
+        check('spec repo paths', impact.repo_paths.some((repoPath) => repoPath.endsWith('.cy.js')), `Impact acceptance for '${changedFile}' must include Cypress spec paths, not just the changed file.`, `Spec paths: ${impact.repo_paths.filter((repoPath) => repoPath.endsWith('.cy.js')).length}`),
+    ];
+}
+export function evaluateBlueprintAcceptance(blueprint, feature) {
+    const draft = blueprint.evidence.find((item) => item.label === 'blueprint')?.snippet ?? '';
+    const hasReferenceSpecs = blueprint.evidence.some((item) => item.label === 'reference spec');
+    const hasImportTarget = /support\/base(?:Conf)?/.test(draft);
+    const hasSetupShape = draft.includes('before(() => {') && draft.includes('beforeEach(() => {');
+    const hasSelectorGuidance = blueprint.recommended_actions.some((action) => action.toLowerCase().includes('selector'));
+    const hasReuseGuidance = blueprint.recommended_actions.some((action) => action.toLowerCase().includes('reuse') || action.toLowerCase().includes('borrow'));
+    return [
+        check('reference specs', hasReferenceSpecs, `Blueprint acceptance for '${feature}' requires real reference specs from autotests2.`, 'Reference specs are attached as evidence.'),
+        check('non-placeholder import', draft.length > 0 && !draft.includes("from '...'") && hasImportTarget, `Blueprint acceptance for '${feature}' requires a real import target instead of demo-level placeholders.`, 'Blueprint contains a concrete support import target.'),
+        check('setup guidance', hasSetupShape && draft.includes('cy.getWidget('), `Blueprint acceptance for '${feature}' requires usable before/beforeEach structure and widget access guidance.`, 'Blueprint contains before/beforeEach hooks and widget access patterns.'),
+        check('selector and reuse guidance', hasSelectorGuidance && hasReuseGuidance, `Blueprint acceptance for '${feature}' requires explicit selector and reuse guidance.`, 'Recommended actions include selector and reuse guidance.'),
+    ];
+}
+export function assertPassingChecks(report) {
+    const failedChecks = report.checks.filter((checkResult) => !checkResult.passed);
+    if (failedChecks.length === 0) {
+        return;
+    }
+    const details = failedChecks.map((checkResult) => `${checkResult.name}: ${checkResult.detail}`).join(' | ');
+    throw new Error(`${report.mode} acceptance failed for '${report.target}'. ${details}`);
+}
+function check(name, passed, failedDetail, passedDetail) {
+    return {
+        name,
+        passed,
+        detail: passed ? passedDetail : failedDetail,
+    };
+}
+export async function runAcceptanceCli(argv = process.argv.slice(2)) {
+    const [rawMode, ...args] = argv;
+    if (!isAcceptanceMode(rawMode)) {
+        console.error(`Unknown acceptance mode '${rawMode}'. Use coverage, failure, impact, or blueprint.`);
+        process.exit(1);
+    }
+    const context = await createRuntimeAppContext();
+    const report = await evaluateAcceptanceMode(rawMode, args, context);
+    try {
+        assertPassingChecks(report);
+        console.log(JSON.stringify(report, null, 2));
+    }
+    catch (error) {
+        console.error(JSON.stringify(report, null, 2));
+        throw error;
+    }
+}
+function isAcceptanceMode(value) {
+    return value === 'coverage' || value === 'failure' || value === 'impact' || value === 'blueprint';
+}
+if (isDirectExecution(import.meta.url)) {
+    await runAcceptanceCli();
+}

package/dist/src/cli/runMcpServer.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;

package/dist/src/cli/runMcpServer.js

@@ -0,0 +1,10 @@
+import { createRuntimeAppContext } from '../appContext.js';
+import { runMcpServer } from '../mcp/server.js';
+import { isDirectExecution } from './shared.js';
+export async function startMcpServer() {
+    const context = await createRuntimeAppContext();
+    await runMcpServer(context);
+}
+if (isDirectExecution(import.meta.url)) {
+    await startMcpServer();
+}

package/dist/src/cli/shared.d.ts

@@ -0,0 +1 @@
+export declare function isDirectExecution(moduleUrl: string): boolean;

package/dist/src/cli/shared.js

@@ -0,0 +1,7 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function isDirectExecution(moduleUrl) {
+    const currentFile = fileURLToPath(moduleUrl);
+    const entryFile = process.argv[1] ? path.resolve(process.argv[1]) : '';
+    return currentFile === entryFile;
+}

package/dist/src/config/consumerConfig.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+export declare const consumerConfigSchema: z.ZodObject<{
+    repos: z.ZodObject<{
+        autotests2: z.ZodString;
+        caseplatformWeb: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        autotests2: string;
+        caseplatformWeb: string;
+    }, {
+        autotests2: string;
+        caseplatformWeb: string;
+    }>;
+    ci: z.ZodObject<{
+        artifactsRoot: z.ZodString;
+        reportPortal: z.ZodOptional<z.ZodObject<{
+            endpoint: z.ZodString;
+            project: z.ZodOptional<z.ZodString>;
+            token: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            endpoint: string;
+            project?: string | undefined;
+            token?: string | undefined;
+        }, {
+            endpoint: string;
+            project?: string | undefined;
+            token?: string | undefined;
+        }>>;
+        gitlab: z.ZodOptional<z.ZodObject<{
+            baseUrl: z.ZodString;
+            projectId: z.ZodOptional<z.ZodString>;
+            token: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            baseUrl: string;
+            token?: string | undefined;
+            projectId?: string | undefined;
+        }, {
+            baseUrl: string;
+            token?: string | undefined;
+            projectId?: string | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        artifactsRoot: string;
+        reportPortal?: {
+            endpoint: string;
+            project?: string | undefined;
+            token?: string | undefined;
+        } | undefined;
+        gitlab?: {
+            baseUrl: string;
+            token?: string | undefined;
+            projectId?: string | undefined;
+        } | undefined;
+    }, {
+        artifactsRoot: string;
+        reportPortal?: {
+            endpoint: string;
+            project?: string | undefined;
+            token?: string | undefined;
+        } | undefined;
+        gitlab?: {
+            baseUrl: string;
+            token?: string | undefined;
+            projectId?: string | undefined;
+        } | undefined;
+    }>;
+    cacheDir: z.ZodOptional<z.ZodString>;
+    projectHints: z.ZodOptional<z.ZodObject<{
+        defaultWidget: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        defaultWidget?: string | undefined;
+    }, {
+        defaultWidget?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    repos: {
+        autotests2: string;
+        caseplatformWeb: string;
+    };
+    ci: {
+        artifactsRoot: string;
+        reportPortal?: {
+            endpoint: string;
+            project?: string | undefined;
+            token?: string | undefined;
+        } | undefined;
+        gitlab?: {
+            baseUrl: string;
+            token?: string | undefined;
+            projectId?: string | undefined;
+        } | undefined;
+    };
+    cacheDir?: string | undefined;
+    projectHints?: {
+        defaultWidget?: string | undefined;
+    } | undefined;
+}, {
+    repos: {
+        autotests2: string;
+        caseplatformWeb: string;
+    };
+    ci: {
+        artifactsRoot: string;
+        reportPortal?: {
+            endpoint: string;
+            project?: string | undefined;
+            token?: string | undefined;
+        } | undefined;
+        gitlab?: {
+            baseUrl: string;
+            token?: string | undefined;
+            projectId?: string | undefined;
+        } | undefined;
+    };
+    cacheDir?: string | undefined;
+    projectHints?: {
+        defaultWidget?: string | undefined;
+    } | undefined;
+}>;
+export type ConsumerConfigInput = z.input<typeof consumerConfigSchema>;
+export type ConsumerConfig = z.output<typeof consumerConfigSchema> & {
+    cacheDir: string;
+};
+export declare function resolveRepoPath(value: string, baseDir?: string): string;
+export declare function parseConsumerConfig(input: ConsumerConfigInput, baseDir?: string): ConsumerConfig;
+export declare function loadConsumerConfig(configPath?: string): ConsumerConfig;
+export declare function createDefaultConsumerConfig(baseDir?: string): ConsumerConfig;