@mcoda/core 0.1.8 → 0.1.11

package/dist/services/docs/review/gates/DeploymentBlueprintGate.js

@@ -0,0 +1,487 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+const DEPENDENCY_DEFINITIONS = [
+    { key: "mysql", label: "MySQL", keywords: ["mysql", "mariadb"] },
+    { key: "redis", label: "Redis", keywords: ["redis"] },
+    { key: "nats", label: "NATS", keywords: ["nats"] },
+    { key: "minio", label: "MinIO", keywords: ["minio", "object storage", "s3"] },
+    { key: "clickhouse", label: "ClickHouse", keywords: ["clickhouse"] },
+];
+const ENV_REF_PATTERN = /\${([A-Z][A-Z0-9_]+)}/g;
+const ENV_SECTION_PATTERN = /^\s*(environment|data|stringData)\s*:\s*$/i;
+const ENV_KEY_PATTERN = /^\s*([A-Z][A-Z0-9_]+)\s*:/;
+const SERVICE_PORT_NAME = "SERVICE_PORT";
+const isFenceLine = (line) => /^```|^~~~/.test(line.trim());
+const extractDependencies = (content) => {
+    const matches = new Map();
+    const lines = content.split(/\r?\n/);
+    let inFence = false;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trim();
+        if (isFenceLine(trimmed)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence || !trimmed)
+            continue;
+        const normalized = trimmed.toLowerCase();
+        for (const dependency of DEPENDENCY_DEFINITIONS) {
+            if (matches.has(dependency.key))
+                continue;
+            const keyword = dependency.keywords.find((entry) => normalized.includes(entry));
+            if (keyword) {
+                matches.set(dependency.key, { line: i + 1, keyword });
+            }
+        }
+    }
+    return matches;
+};
+const parseEnvExample = (content) => {
+    const names = new Set();
+    const lineMap = new Map();
+    let port;
+    const lines = content.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            return;
+        const [rawName, rawValue] = trimmed.split("=", 2);
+        const name = rawName?.trim();
+        if (!name || !/^[A-Z][A-Z0-9_]+$/.test(name))
+            return;
+        names.add(name);
+        if (!lineMap.has(name)) {
+            lineMap.set(name, index + 1);
+        }
+        if (name === SERVICE_PORT_NAME && rawValue) {
+            const parsed = Number.parseInt(rawValue.trim(), 10);
+            if (Number.isFinite(parsed))
+                port = parsed;
+        }
+    });
+    return { names, port, lineMap };
+};
+const parseEnvDoc = (content) => {
+    const names = new Set();
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+        if (!line.includes("|"))
+            continue;
+        const columns = line.split("|").map((entry) => entry.trim());
+        if (columns.length < 3)
+            continue;
+        const name = columns[1];
+        if (!name || name.toLowerCase() === "name")
+            continue;
+        if (/^[A-Z][A-Z0-9_]+$/.test(name)) {
+            names.add(name);
+        }
+    }
+    return names;
+};
+const collectEnvReferences = async (record) => {
+    const refs = new Map();
+    try {
+        const content = await fs.readFile(record.path, "utf8");
+        const lines = content.split(/\r?\n/);
+        let inSection = false;
+        let sectionIndent = 0;
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i] ?? "";
+            const trimmed = line.trim();
+            const sectionMatch = line.match(ENV_SECTION_PATTERN);
+            if (sectionMatch) {
+                inSection = true;
+                sectionIndent = line.match(/^\s*/)?.[0]?.length ?? 0;
+                continue;
+            }
+            const indent = line.match(/^\s*/)?.[0]?.length ?? 0;
+            if (inSection && indent <= sectionIndent && trimmed.length > 0) {
+                inSection = false;
+            }
+            if (inSection) {
+                const keyMatch = line.match(ENV_KEY_PATTERN);
+                if (keyMatch?.[1]) {
+                    if (!refs.has(keyMatch[1])) {
+                        refs.set(keyMatch[1], { path: record.path, line: i + 1 });
+                    }
+                }
+            }
+            const envRegex = new RegExp(ENV_REF_PATTERN);
+            let match;
+            while ((match = envRegex.exec(line)) !== null) {
+                const name = match[1];
+                if (name && !refs.has(name)) {
+                    refs.set(name, { path: record.path, line: i + 1 });
+                }
+            }
+        }
+    }
+    catch {
+        return refs;
+    }
+    return refs;
+};
+const extractComposeServices = (content) => {
+    const services = new Map();
+    const lines = content.split(/\r?\n/);
+    let inServices = false;
+    let baseIndent = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (!inServices && /^services\s*:/i.test(trimmed)) {
+            inServices = true;
+            baseIndent = line.match(/^\s*/)?.[0]?.length ?? 0;
+            continue;
+        }
+        if (inServices) {
+            const indent = line.match(/^\s*/)?.[0]?.length ?? 0;
+            if (indent <= baseIndent) {
+                inServices = false;
+                continue;
+            }
+            const match = line.match(/^\s*([A-Za-z0-9_-]+)\s*:\s*$/);
+            if (match?.[1]) {
+                services.set(match[1], i + 1);
+            }
+        }
+    }
+    return services;
+};
+const extractServicesFromBlueprints = async (records) => {
+    const services = new Map();
+    const compose = records.find((record) => path.basename(record.path).toLowerCase().includes("docker-compose"));
+    if (compose) {
+        try {
+            const content = await fs.readFile(compose.path, "utf8");
+            const extracted = extractComposeServices(content);
+            extracted.forEach((line, name) => {
+                services.set(name, { path: compose.path, line });
+            });
+            return services;
+        }
+        catch {
+            // fall through to filename-based detection
+        }
+    }
+    for (const record of records) {
+        const base = path.basename(record.path).toLowerCase();
+        if (!base.endsWith("-deployment.yaml") && !base.endsWith("-deployment.yml")) {
+            continue;
+        }
+        const name = base.replace(/-deployment\.ya?ml$/i, "");
+        if (!services.has(name)) {
+            services.set(name, { path: record.path, line: 1 });
+        }
+    }
+    return services;
+};
+const parseOpenApi = (raw) => {
+    if (!raw || !raw.trim())
+        return undefined;
+    try {
+        return YAML.parse(raw);
+    }
+    catch {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    }
+};
+const extractPortFromUrl = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed);
+    try {
+        const parsed = new URL(hasScheme ? trimmed : `http://${trimmed}`);
+        if (parsed.port)
+            return Number(parsed.port);
+        if (hasScheme) {
+            if (parsed.protocol === "https:")
+                return 443;
+            if (parsed.protocol === "http:")
+                return 80;
+        }
+    }
+    catch {
+        const portMatch = trimmed.match(/:(\d{2,5})(?:\/|$)/);
+        if (portMatch)
+            return Number(portMatch[1]);
+    }
+    return undefined;
+};
+const extractOpenApiPorts = (content) => {
+    const doc = parseOpenApi(content);
+    const ports = [];
+    const servers = Array.isArray(doc?.servers) ? doc.servers : [];
+    for (const server of servers) {
+        if (!server || typeof server.url !== "string")
+            continue;
+        const port = extractPortFromUrl(server.url);
+        if (port)
+            ports.push(port);
+    }
+    return ports;
+};
+const buildIssue = (input) => ({
+    id: input.id,
+    gateId: "gate-deployment-blueprint-validator",
+    severity: input.severity,
+    category: "deployment",
+    artifact: "deployment",
+    message: input.message,
+    remediation: input.remediation,
+    location: input.location,
+    metadata: input.metadata,
+});
+export const runDeploymentBlueprintGate = async (input) => {
+    const { artifacts, buildReady } = input;
+    const blueprintRecords = artifacts.blueprints ?? [];
+    if (blueprintRecords.length === 0) {
+        return {
+            gateId: "gate-deployment-blueprint-validator",
+            gateName: "Deployment Blueprint Validator",
+            status: "skipped",
+            issues: [],
+            notes: ["No deployment blueprint artifacts available for validation."],
+        };
+    }
+    if (!artifacts.sds) {
+        return {
+            gateId: "gate-deployment-blueprint-validator",
+            gateName: "Deployment Blueprint Validator",
+            status: "skipped",
+            issues: [],
+            notes: ["No SDS artifact available for deployment blueprint validation."],
+        };
+    }
+    const issues = [];
+    const notes = [];
+    const envExampleRecord = blueprintRecords.find((record) => path.basename(record.path).toLowerCase().endsWith(".env.example"));
+    const envDocRecord = blueprintRecords.find((record) => path.basename(record.path).toLowerCase().includes("env-secrets"));
+    const manifestRecords = blueprintRecords.filter((record) => record !== envExampleRecord && record !== envDocRecord);
+    let envExample;
+    if (envExampleRecord) {
+        try {
+            envExample = parseEnvExample(await fs.readFile(envExampleRecord.path, "utf8"));
+        }
+        catch (error) {
+            notes.push(`Unable to read env example ${envExampleRecord.path}: ${error.message ?? String(error)}`);
+        }
+    }
+    let envDocNames;
+    if (envDocRecord) {
+        try {
+            envDocNames = parseEnvDoc(await fs.readFile(envDocRecord.path, "utf8"));
+        }
+        catch (error) {
+            notes.push(`Unable to read env mapping doc ${envDocRecord.path}: ${error.message ?? String(error)}`);
+        }
+    }
+    const manifestEnvRefs = new Map();
+    for (const record of manifestRecords) {
+        const refs = await collectEnvReferences(record);
+        refs.forEach((value, key) => {
+            if (!manifestEnvRefs.has(key))
+                manifestEnvRefs.set(key, value);
+        });
+    }
+    if (manifestEnvRefs.size > 0) {
+        if (!envExampleRecord) {
+            issues.push(buildIssue({
+                id: "gate-deployment-blueprint-missing-env-example",
+                severity: "high",
+                message: "Deployment blueprint is missing .env.example for manifest env vars.",
+                remediation: "Provide a .env.example file listing all manifest environment variables.",
+                location: {
+                    kind: "heading",
+                    heading: "Deployment",
+                    path: manifestRecords[0]?.path,
+                },
+                metadata: { issueType: "missing_env_example_file" },
+            }));
+        }
+        if (!envDocRecord) {
+            issues.push(buildIssue({
+                id: "gate-deployment-blueprint-missing-env-doc",
+                severity: "medium",
+                message: "Deployment blueprint is missing env-secrets documentation.",
+                remediation: "Document deployment environment variables in env-secrets.md.",
+                location: {
+                    kind: "heading",
+                    heading: "Deployment",
+                    path: manifestRecords[0]?.path,
+                },
+                metadata: { issueType: "missing_env_doc_file" },
+            }));
+        }
+    }
+    if (envExample) {
+        for (const [name, reference] of manifestEnvRefs.entries()) {
+            if (!envExample.names.has(name)) {
+                issues.push(buildIssue({
+                    id: `gate-deployment-blueprint-missing-env-example-${name.toLowerCase()}`,
+                    severity: "high",
+                    message: `Environment variable ${name} is referenced in manifests but missing from .env.example.`,
+                    remediation: `Add ${name} to .env.example and document its usage.`,
+                    location: {
+                        kind: "line_range",
+                        path: reference.path,
+                        lineStart: reference.line,
+                        lineEnd: reference.line,
+                        excerpt: name,
+                    },
+                    metadata: { issueType: "missing_env_example", name },
+                }));
+            }
+        }
+    }
+    if (envDocNames) {
+        for (const [name, reference] of manifestEnvRefs.entries()) {
+            if (!envDocNames.has(name)) {
+                issues.push(buildIssue({
+                    id: `gate-deployment-blueprint-missing-env-doc-${name.toLowerCase()}`,
+                    severity: "medium",
+                    message: `Environment variable ${name} is referenced in manifests but missing from env-secrets.md.`,
+                    remediation: `Document ${name} in env-secrets.md with usage details.`,
+                    location: {
+                        kind: "line_range",
+                        path: reference.path,
+                        lineStart: reference.line,
+                        lineEnd: reference.line,
+                        excerpt: name,
+                    },
+                    metadata: { issueType: "missing_env_documentation", name },
+                }));
+            }
+        }
+    }
+    let expectedDependencies = new Map();
+    try {
+        const sdsContent = await fs.readFile(artifacts.sds.path, "utf8");
+        expectedDependencies = extractDependencies(sdsContent);
+    }
+    catch (error) {
+        notes.push(`Unable to read SDS ${artifacts.sds.path}: ${error.message ?? String(error)}`);
+    }
+    const detectedServices = await extractServicesFromBlueprints(blueprintRecords);
+    const detectedDependencyKeys = new Set();
+    detectedServices.forEach((_value, name) => {
+        const key = DEPENDENCY_DEFINITIONS.find((entry) => entry.key === name)?.key;
+        if (key)
+            detectedDependencyKeys.add(key);
+    });
+    for (const dependency of DEPENDENCY_DEFINITIONS) {
+        const expected = expectedDependencies.has(dependency.key);
+        const actual = detectedDependencyKeys.has(dependency.key);
+        if (expected && !actual) {
+            const match = expectedDependencies.get(dependency.key);
+            issues.push(buildIssue({
+                id: `gate-deployment-blueprint-missing-dependency-${dependency.key}`,
+                severity: "high",
+                message: `Deployment blueprint is missing ${dependency.label} even though SDS references it.`,
+                remediation: `Add ${dependency.label} services/manifests to the deployment blueprint.`,
+                location: {
+                    kind: "line_range",
+                    path: artifacts.sds.path,
+                    lineStart: match?.line ?? 1,
+                    lineEnd: match?.line ?? 1,
+                    excerpt: match?.keyword ?? dependency.label,
+                },
+                metadata: { issueType: "missing_dependency", dependency: dependency.key },
+            }));
+        }
+        if (!expected && actual) {
+            const serviceInfo = detectedServices.get(dependency.key);
+            issues.push(buildIssue({
+                id: `gate-deployment-blueprint-unexpected-dependency-${dependency.key}`,
+                severity: "medium",
+                message: `Deployment blueprint includes ${dependency.label} but SDS does not select it.`,
+                remediation: `Remove ${dependency.label} from manifests or update SDS decisions.`,
+                location: {
+                    kind: "line_range",
+                    path: serviceInfo?.path ?? envExampleRecord?.path ?? artifacts.sds.path,
+                    lineStart: serviceInfo?.line ?? 1,
+                    lineEnd: serviceInfo?.line ?? 1,
+                    excerpt: dependency.label,
+                },
+                metadata: { issueType: "unexpected_dependency", dependency: dependency.key },
+            }));
+        }
+    }
+    const openapiPorts = [];
+    if (artifacts.openapi?.length) {
+        for (const record of artifacts.openapi) {
+            try {
+                const content = await fs.readFile(record.path, "utf8");
+                const ports = extractOpenApiPorts(content);
+                if (ports.length > 0) {
+                    openapiPorts.push(...ports);
+                }
+            }
+            catch (error) {
+                notes.push(`Unable to read OpenAPI spec ${record.path}: ${error.message ?? String(error)}`);
+            }
+        }
+    }
+    if (openapiPorts.length > 0) {
+        const expectedPort = envExample?.port;
+        if (!expectedPort) {
+            issues.push(buildIssue({
+                id: "gate-deployment-blueprint-missing-service-port",
+                severity: "medium",
+                message: "Deployment blueprint is missing SERVICE_PORT for OpenAPI server alignment.",
+                remediation: "Include SERVICE_PORT in .env.example and ensure manifests reference it.",
+                location: {
+                    kind: "heading",
+                    heading: "Deployment",
+                    path: envExampleRecord?.path ?? artifacts.sds.path,
+                },
+                metadata: { issueType: "missing_service_port" },
+            }));
+        }
+        else if (!openapiPorts.includes(expectedPort)) {
+            issues.push(buildIssue({
+                id: "gate-deployment-blueprint-port-mismatch",
+                severity: "high",
+                message: `Deployment blueprint uses port ${expectedPort} but OpenAPI servers use ${openapiPorts.join(", ")}.`,
+                remediation: "Align SERVICE_PORT and manifests with the OpenAPI server port.",
+                location: {
+                    kind: "line_range",
+                    path: envExampleRecord?.path ?? artifacts.sds.path,
+                    lineStart: envExample?.lineMap.get(SERVICE_PORT_NAME) ?? 1,
+                    lineEnd: envExample?.lineMap.get(SERVICE_PORT_NAME) ?? 1,
+                    excerpt: SERVICE_PORT_NAME,
+                },
+                metadata: {
+                    issueType: "port_mismatch",
+                    servicePort: expectedPort,
+                    openapiPorts,
+                },
+            }));
+        }
+    }
+    const status = issues.length === 0 ? "pass" : buildReady ? "fail" : "warn";
+    return {
+        gateId: "gate-deployment-blueprint-validator",
+        gateName: "Deployment Blueprint Validator",
+        status,
+        issues,
+        notes: notes.length ? notes : undefined,
+        metadata: {
+            envVarsReferenced: Array.from(manifestEnvRefs.keys()),
+            serviceDependenciesExpected: Array.from(expectedDependencies.keys()),
+            serviceDependenciesDetected: Array.from(detectedDependencyKeys),
+            openapiPorts,
+        },
+    };
+};

package/dist/services/docs/review/gates/NoMaybesGate.d.ts

@@ -0,0 +1,8 @@
+import { DocgenArtifactInventory } from "../../DocgenRunContext.js";
+import { ReviewGateResult } from "../ReviewTypes.js";
+export interface NoMaybesGateInput {
+    artifacts: DocgenArtifactInventory;
+    enabled: boolean;
+}
+export declare const runNoMaybesGate: (input: NoMaybesGateInput) => Promise<ReviewGateResult>;
+//# sourceMappingURL=NoMaybesGate.d.ts.map

package/dist/services/docs/review/gates/NoMaybesGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoMaybesGate.d.ts","sourceRoot":"","sources":["../../../../../src/services/docs/review/gates/NoMaybesGate.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAA+B,MAAM,mBAAmB,CAAC;AAElF,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,uBAAuB,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC;CAClB;AAoID,eAAO,MAAM,eAAe,GAAU,OAAO,iBAAiB,KAAG,OAAO,CAAC,gBAAgB,CAwCxF,CAAC"}

package/dist/services/docs/review/gates/NoMaybesGate.js

@@ -0,0 +1,145 @@
+import { promises as fs } from "node:fs";
+const INDECISIVE_PATTERNS = [
+    { id: "maybe", label: "Maybe language", pattern: /\bmaybe\b/i },
+    { id: "optional", label: "Optional language", pattern: /\boptional\b/i },
+    { id: "could", label: "Could language", pattern: /\bcould\b/i },
+    { id: "might", label: "Might language", pattern: /\bmight\b/i },
+    { id: "possibly", label: "Possibly language", pattern: /\bpossibly\b/i },
+    { id: "either", label: "Either/Or language", pattern: /\beither\b/i },
+    { id: "tbd", label: "TBD language", pattern: /\btbd\b/i },
+];
+const DECISION_HEADINGS = [
+    /architecture/i,
+    /technology stack/i,
+    /tech stack/i,
+    /deployment/i,
+    /security/i,
+    /data model/i,
+    /interfaces/i,
+    /operations/i,
+    /ops/i,
+];
+const OPTIONS_HEADINGS = [/options considered/i, /alternatives/i, /trade-?offs/i, /choices/i];
+const isFenceLine = (line) => /^```|^~~~/.test(line.trim());
+const headingLevel = (heading) => heading.match(/^#{1,6}/)?.[0].length ?? 0;
+const matchesHeading = (heading, patterns) => patterns.some((pattern) => pattern.test(heading));
+const buildIssue = (input) => {
+    const severity = "medium";
+    const message = `${input.pattern.label} detected in decision-required section.`;
+    return {
+        id: `gate-no-maybes-${input.record.kind}-${input.pattern.id}-${input.lineNumber}`,
+        gateId: "gate-no-maybes",
+        severity,
+        category: "decision",
+        artifact: input.record.kind,
+        message,
+        remediation: "Replace indecisive language with a concrete decision.",
+        location: {
+            kind: "line_range",
+            path: input.record.path,
+            lineStart: input.lineNumber,
+            lineEnd: input.lineNumber,
+            excerpt: input.pattern.label,
+        },
+        metadata: {
+            patternId: input.pattern.id,
+            heading: input.heading,
+        },
+    };
+};
+const scanRecord = async (record) => {
+    const issues = [];
+    const notes = [];
+    try {
+        const content = await fs.readFile(record.path, "utf8");
+        const lines = content.split(/\r?\n/);
+        let inFence = false;
+        let decisionLevel = null;
+        let optionsLevel = null;
+        let currentHeading;
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i] ?? "";
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (isFenceLine(trimmed)) {
+                inFence = !inFence;
+                continue;
+            }
+            const headingMatch = trimmed.match(/^#{1,6}\s+(.*)$/);
+            if (headingMatch) {
+                const level = headingLevel(trimmed);
+                currentHeading = headingMatch[1]?.trim() || undefined;
+                if (currentHeading && matchesHeading(currentHeading, OPTIONS_HEADINGS)) {
+                    optionsLevel = level;
+                }
+                else if (currentHeading && matchesHeading(currentHeading, DECISION_HEADINGS)) {
+                    decisionLevel = level;
+                    optionsLevel = null;
+                }
+                else {
+                    if (decisionLevel !== null && level <= decisionLevel)
+                        decisionLevel = null;
+                    if (optionsLevel !== null && level <= optionsLevel)
+                        optionsLevel = null;
+                }
+                continue;
+            }
+            if (inFence)
+                continue;
+            const inDecisionSection = decisionLevel !== null && optionsLevel === null;
+            if (!inDecisionSection)
+                continue;
+            for (const pattern of INDECISIVE_PATTERNS) {
+                if (!pattern.pattern.test(trimmed))
+                    continue;
+                issues.push(buildIssue({
+                    record,
+                    lineNumber: i + 1,
+                    pattern,
+                    heading: currentHeading,
+                }));
+            }
+        }
+    }
+    catch (error) {
+        notes.push(`Unable to scan ${record.path}: ${error.message ?? String(error)}`);
+    }
+    return { issues, notes };
+};
+export const runNoMaybesGate = async (input) => {
+    if (!input.enabled) {
+        return {
+            gateId: "gate-no-maybes",
+            gateName: "No Maybes",
+            status: "skipped",
+            issues: [],
+            notes: ["No-maybes gate disabled."],
+        };
+    }
+    const records = [input.artifacts.pdr, input.artifacts.sds].filter((record) => Boolean(record));
+    if (records.length === 0) {
+        return {
+            gateId: "gate-no-maybes",
+            gateName: "No Maybes",
+            status: "skipped",
+            issues: [],
+            notes: ["No PDR/SDS artifacts available for indecisive language checks."],
+        };
+    }
+    const issues = [];
+    const notes = [];
+    for (const record of records) {
+        const result = await scanRecord(record);
+        issues.push(...result.issues);
+        notes.push(...result.notes);
+    }
+    const status = issues.length > 0 ? "fail" : "pass";
+    return {
+        gateId: "gate-no-maybes",
+        gateName: "No Maybes",
+        status,
+        issues,
+        notes: notes.length > 0 ? notes : undefined,
+    };
+};

package/dist/services/docs/review/gates/OpenApiCoverageGate.d.ts

@@ -0,0 +1,7 @@
+import { DocgenArtifactInventory } from "../../DocgenRunContext.js";
+import { ReviewGateResult } from "../ReviewTypes.js";
+export interface OpenApiCoverageGateInput {
+    artifacts: DocgenArtifactInventory;
+}
+export declare const runOpenApiCoverageGate: (input: OpenApiCoverageGateInput) => Promise<ReviewGateResult>;
+//# sourceMappingURL=OpenApiCoverageGate.d.ts.map

package/dist/services/docs/review/gates/OpenApiCoverageGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenApiCoverageGate.d.ts","sourceRoot":"","sources":["../../../../../src/services/docs/review/gates/OpenApiCoverageGate.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAA+B,MAAM,mBAAmB,CAAC;AAOlF,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,uBAAuB,CAAC;CACpC;AA2ND,eAAO,MAAM,sBAAsB,GACjC,OAAO,wBAAwB,KAC9B,OAAO,CAAC,gBAAgB,CA+E1B,CAAC"}